added lifetime link suppoert

internal/routes/stream.go

@@ -123,7 +123,7 @@ func getStreamRoute(ctx *gin.Context) {
 	ctx.Header("Content-Disposition", fmt.Sprintf("%s; filename=\"%s\"", disposition, file.FileName))
 
 	if r.Method != "HEAD" {
-		lr, _ := utils.NewTelegramReader(ctx, worker.Client, file.Location, start, end, contentLength)
+		lr, _ := utils.NewTelegramReader(ctx, worker.Client, file.Location, start, end, contentLength, messageID)
 		if _, err := io.CopyN(w, lr, contentLength); err != nil {
 			log.Error("Error while copying stream", zap.Error(err))
 		}

internal/utils/helpers.go

@@ -179,3 +179,40 @@ func ForwardMessages(ctx *ext.Context, fromChatId, toChatId int64, messageID int
 	}
 	return update.(*tg.Updates), nil
 }
+
+
+// Add this entire function to the end of internal/utils/helpers.go
+
+// RefreshFileReference gets a new file reference for a message and updates the cache.
+func RefreshFileReference(ctx context.Context, client *gotgproto.Client, messageID int) (*types.File, error) {
+	key := fmt.Sprintf("file:%d:%d", messageID, client.Self.ID)
+	log := Logger.Named("RefreshFileReference")
+
+	log.Debug("Refreshing file reference from Telegram", zap.Int("messageID", messageID), zap.Int64("clientID", client.Self.ID))
+	
+	// Step 1: Get the message again from the API to get a fresh file_reference.
+	message, err := GetTGMessage(ctx, client, messageID)
+	if err != nil {
+		return nil, err
+	}
+
+	// Step 2: Convert the message media into our internal File type.
+	file, err := FileFromMedia(message.Media)
+	if err != nil {
+		return nil, err
+	}
+
+	// Step 3: Update the cache with the new, valid file data.
+	err = cache.GetCache().Set(
+		key,
+		file,
+		3600, // Cache for 1 hour
+	)
+	if err != nil {
+		// If caching fails, we can still proceed, but log the error.
+		log.Error("Failed to update cache with new file reference", zap.Error(err))
+	}
+	
+	log.Debug("Successfully refreshed file reference and updated cache.", zap.Int("messageID", messageID))
+	return file, nil
+}

internal/utils/reader.go

@@ -11,6 +11,7 @@ import (
 )
 
 type telegramReader struct {
+	messageID     int 			 
 	ctx           context.Context
 	log           *zap.Logger
 	client        *gotgproto.Client
@@ -36,9 +37,11 @@ func NewTelegramReader(
 	start int64,
 	end int64,
 	contentLength int64,
+	messageID int 
 ) (io.ReadCloser, error) {
 
 	r := &telegramReader{
+		messageID:     messageID,
 		ctx:           ctx,
 		log:           Logger.Named("telegramReader"),
 		location:      location,
@@ -92,6 +95,30 @@ func (r *telegramReader) chunk(offset int64, limit int64) ([]byte, error) {
 
 	res, err := r.client.API().UploadGetFile(r.ctx, req)
 
+	// Check if the file reference has expired.
+	if err != nil {
+		if tgerr.Is(err, "FILE_REFERENCE_EXPIRED") {
+			r.log.Info("File reference expired. Attempting to refresh.", zap.Int("messageID", r.messageID))
+			
+			// Call our new refresh function from helpers.go
+			newFile, refreshErr := RefreshFileReference(r.ctx, r.client, r.messageID)
+			if refreshErr != nil {
+				r.log.Error("Failed to refresh file reference after it expired.", zap.Error(refreshErr))
+				// If we can't refresh, return the original "expired" error.
+				return nil, err
+			}
+
+			// Refresh was successful! Update the reader's location and the request object.
+			r.location = newFile.Location
+			req.Location = newFile.Location
+			r.log.Info("File reference refreshed successfully. Retrying file download.")
+
+			// Retry the download with the new, valid reference.
+			res, err = r.client.API().UploadGetFile(r.ctx, req)
+		}
+	}
+
+	// After the potential retry, check for errors one last time.
 	if err != nil {
 		return nil, err
 	}