feat(task): expose offline download file info

gengjiawen · codex · gengjiawen · commit 9f22022e50c2 · 2026-06-05T02:09:01.000Z
Co-authored-by: Codex &lt;codex@openai.com&gt;
diff --git a/internal/offline_download/115/client.go b/internal/offline_download/115/client.go
@@ -126,8 +126,10 @@ func (p *Cloud115) Status(task *tool.DownloadTask) (*tool.Status, error) {
 			s.Status = t.GetStatus()
 			s.Completed = t.IsDone()
 			s.TotalBytes = t.Size
+			s.FileName = t.Name
+			s.FileSize = t.Size
 			if t.IsFailed() {
-				s.Err = fmt.Errorf(t.GetStatus())
+				s.Err = fmt.Errorf("%s", t.GetStatus())
 			}
 			return s, nil
 		}
diff --git a/internal/offline_download/115_open/client.go b/internal/offline_download/115_open/client.go
@@ -123,8 +123,10 @@ func (o *Open115) Status(task *tool.DownloadTask) (*tool.Status, error) {
 			s.Status = t.GetStatus()
 			s.Completed = t.IsDone()
 			s.TotalBytes = t.Size
+			s.FileName = t.Name
+			s.FileSize = t.Size
 			if t.IsFailed() {
-				s.Err = fmt.Errorf(t.GetStatus())
+				s.Err = fmt.Errorf("%s", t.GetStatus())
 			}
 			return s, nil
 		}
diff --git a/internal/offline_download/123/client.go b/internal/offline_download/123/client.go
@@ -128,13 +128,22 @@ func (*Pan123) Status(task *tool.DownloadTask) (*tool.Status, error) {
 
 	return &tool.Status{
 		TotalBytes: t.Size,
+		FileName:   offlineTaskFileName(t.Name, t.UploadName),
+		FileSize:   t.Size,
 		Progress:   t.Progress,
 		Completed:  completed,
 		Status:     statusStr,
 		Err:        taskErr,
 	}, nil
 }
 
+func offlineTaskFileName(name, uploadName string) string {
+	if uploadName != "" {
+		return uploadName
+	}
+	return name
+}
+
 var _ tool.Tool = (*Pan123)(nil)
 
 func init() {
diff --git a/internal/offline_download/aria2/aria2.go b/internal/offline_download/aria2/aria2.go
@@ -3,6 +3,7 @@ package aria2
 import (
 	"context"
 	"fmt"
+	"path"
 	"strconv"
 	"strings"
 	"time"
@@ -99,8 +100,12 @@ func (a *Aria2) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		Completed:  info.Status == "complete",
 		Err:        err,
 		TotalBytes: total,
+		FileName:   fileNameFromStatus(info),
+		FileSize:   total,
+	}
+	if total > 0 {
+		s.Progress = float64(downloaded) / float64(total) * 100
 	}
-	s.Progress = float64(downloaded) / float64(total) * 100
 	if len(info.FollowedBy) != 0 {
 		s.NewGID = info.FollowedBy[0]
 		notify.Signals.Delete(task.GID)
@@ -126,6 +131,19 @@ func (a *Aria2) Status(task *tool.DownloadTask) (*tool.Status, error) {
 	return s, nil
 }
 
+func fileNameFromStatus(info rpc.StatusInfo) string {
+	if info.BitTorrent.Info.Name != "" {
+		return info.BitTorrent.Info.Name
+	}
+	for _, file := range info.Files {
+		if file.Selected == "false" || file.Path == "" {
+			continue
+		}
+		return path.Base(file.Path)
+	}
+	return ""
+}
+
 var _ tool.Tool = (*Aria2)(nil)
 
 func init() {
diff --git a/internal/offline_download/http/client.go b/internal/offline_download/http/client.go
@@ -79,11 +79,13 @@ func (s SimpleHttp) Run(task *tool.DownloadTask) error {
 		filename = fmt.Sprintf("%s-%d-%x", filename, time.Now().UnixMilli(), rand.Uint32())
 	}
 	fileSize := resp.ContentLength
+	task.SetFileInfo(filename, fileSize)
 	if streamPut {
 		if fileSize == 0 {
 			start, end, _ := http_range.ParseContentRange(resp.Header.Get("Content-Range"))
 			fileSize = start + end
 		}
+		task.SetFileInfo(filename, fileSize)
 		task.SetTotalBytes(fileSize)
 		task.TempDir = filename
 		return nil
diff --git a/internal/offline_download/pikpak/pikpak.go b/internal/offline_download/pikpak/pikpak.go
@@ -123,13 +123,15 @@ func (p *PikPak) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		if t.ID == task.GID {
 			s.Progress = float64(t.Progress)
 			s.Status = t.Message
+			s.FileName = t.FileName
 			s.Completed = (t.Phase == "PHASE_TYPE_COMPLETE")
 			s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)
 			if err != nil {
 				s.TotalBytes = 0
 			}
+			s.FileSize = s.TotalBytes
 			if t.Phase == "PHASE_TYPE_ERROR" {
-				s.Err = fmt.Errorf(t.Message)
+				s.Err = fmt.Errorf("%s", t.Message)
 			}
 			return s, nil
 		}
diff --git a/internal/offline_download/qbit/qbit.go b/internal/offline_download/qbit/qbit.go
@@ -65,7 +65,13 @@ func (a *QBittorrent) Status(task *tool.DownloadTask) (*tool.Status, error) {
 	}
 	s := &tool.Status{}
 	s.TotalBytes = info.Size
-	s.Progress = float64(info.Completed) / float64(info.Size) * 100
+	s.FileName = info.Name
+	s.FileSize = info.Size
+	if info.Size > 0 {
+		s.Progress = float64(info.Completed) / float64(info.Size) * 100
+	} else {
+		s.Progress = info.Progress * 100
+	}
 	switch info.State {
 	case qbittorrent.UPLOADING, qbittorrent.PAUSEDUP, qbittorrent.QUEUEDUP, qbittorrent.STALLEDUP, qbittorrent.FORCEDUP, qbittorrent.CHECKINGUP:
 		s.Completed = true
diff --git a/internal/offline_download/thunder/thunder.go b/internal/offline_download/thunder/thunder.go
@@ -124,11 +124,13 @@ func (t *Thunder) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		if t.ID == task.GID {
 			s.Progress = float64(t.Progress)
 			s.Status = t.Message
+			s.FileName = t.FileName
 			s.Completed = (t.Phase == "PHASE_TYPE_COMPLETE")
 			s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)
 			if err != nil {
 				s.TotalBytes = 0
 			}
+			s.FileSize = s.TotalBytes
 			if t.Phase == "PHASE_TYPE_ERROR" {
 				s.Err = errors.New(t.Message)
 			}
diff --git a/internal/offline_download/thunder_browser/thunder_browser.go b/internal/offline_download/thunder_browser/thunder_browser.go
@@ -151,11 +151,13 @@ func (t *ThunderBrowser) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		if t.ID == task.GID {
 			s.Progress = float64(t.Progress)
 			s.Status = t.Message
+			s.FileName = t.FileName
 			s.Completed = t.Phase == "PHASE_TYPE_COMPLETE"
 			s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)
 			if err != nil {
 				s.TotalBytes = 0
 			}
+			s.FileSize = s.TotalBytes
 			if t.Phase == "PHASE_TYPE_ERROR" {
 				s.Err = errors.New(t.Message)
 			}
diff --git a/internal/offline_download/thunderx/thunderx.go b/internal/offline_download/thunderx/thunderx.go
@@ -118,11 +118,13 @@ func (t *ThunderX) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		if t.ID == task.GID {
 			s.Progress = float64(t.Progress)
 			s.Status = t.Message
+			s.FileName = t.FileName
 			s.Completed = t.Phase == "PHASE_TYPE_COMPLETE"
 			s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)
 			if err != nil {
 				s.TotalBytes = 0
 			}
+			s.FileSize = s.TotalBytes
 			if t.Phase == "PHASE_TYPE_ERROR" {
 				s.Err = errors.New(t.Message)
 			}
diff --git a/internal/offline_download/tool/add.go b/internal/offline_download/tool/add.go
@@ -175,23 +175,36 @@ func AddURL(ctx context.Context, args *AddURLArgs) (task.TaskExtensionInfo, erro
 		TempDir:      tempDir,
 		DeletePolicy: deletePolicy,
 		Toolname:     args.Tool,
+		FileName:     fileNameFromURL(args.URL),
 		tool:         tool,
 	}
 	DownloadTaskManager.Add(t)
 	return t, nil
 }
 
 func tryPutUrl(ctx context.Context, path, urlStr string) error {
-	var dstName string
-	u, err := url.Parse(urlStr)
-	if err == nil {
-		dstName = stdpath.Base(u.Path)
-	} else {
+	dstName := fileNameFromURL(urlStr)
+	if dstName == "" {
 		dstName = "UnnamedURL"
 	}
 	return fs.PutURL(ctx, path, dstName, urlStr)
 }
 
+func fileNameFromURL(urlStr string) string {
+	u, err := url.Parse(urlStr)
+	if err != nil {
+		return ""
+	}
+	name := stdpath.Base(u.Path)
+	if name == "." || name == "/" {
+		return ""
+	}
+	if decodedName, err := url.PathUnescape(name); err == nil {
+		name = decodedName
+	}
+	return name
+}
+
 func isSimpleHttpSchemeUnsupported(urlStr string) bool {
 	u, err := url.Parse(strings.TrimSpace(urlStr))
 	if err != nil || u.Scheme == "" {
diff --git a/internal/offline_download/tool/base.go b/internal/offline_download/tool/base.go
@@ -13,6 +13,8 @@ type AddUrlArgs struct {
 
 type Status struct {
 	TotalBytes int64
+	FileName   string
+	FileSize   int64
 	Progress   float64
 	NewGID     string
 	Completed  bool
diff --git a/internal/offline_download/tool/download.go b/internal/offline_download/tool/download.go
@@ -25,6 +25,8 @@ type DownloadTask struct {
 	TempDir           string       `json:"temp_dir"`
 	DeletePolicy      DeletePolicy `json:"delete_policy"`
 	Toolname          string       `json:"toolname"`
+	FileName          string       `json:"file_name,omitempty"`
+	FileSize          int64        `json:"file_size,omitempty"`
 	Status            string       `json:"-"`
 	Signal            chan int     `json:"-"`
 	GID               string       `json:"-"`
@@ -153,8 +155,12 @@ func (t *DownloadTask) Update() (bool, error) {
 		return false, nil
 	}
 	t.callStatusRetried = 0
+	totalBytes := max(info.FileSize, info.TotalBytes)
+	t.SetFileInfo(info.FileName, totalBytes)
+	if totalBytes > 0 {
+		t.SetTotalBytes(totalBytes)
+	}
 	t.SetProgress(info.Progress)
-	t.SetTotalBytes(info.TotalBytes)
 	t.Status = fmt.Sprintf("[%s]: %s", t.tool.Name(), info.Status)
 	if info.NewGID != "" {
 		log.Debugf("followen by: %+v", info.NewGID)
@@ -215,6 +221,26 @@ func (t *DownloadTask) GetName() string {
 	return fmt.Sprintf("download %s to (%s)", t.Url, t.DstDirPath)
 }
 
+func (t *DownloadTask) SetFileInfo(fileName string, fileSize int64) {
+	if fileName != "" {
+		t.FileName = fileName
+	}
+	if fileSize > 0 {
+		t.FileSize = fileSize
+	}
+}
+
+func (t *DownloadTask) GetFileName() string {
+	return t.FileName
+}
+
+func (t *DownloadTask) GetFileSize() int64 {
+	if t.FileSize > 0 {
+		return t.FileSize
+	}
+	return t.GetTotalBytes()
+}
+
 func (t *DownloadTask) GetStatus() string {
 	return t.Status
 }
diff --git a/internal/offline_download/transmission/client.go b/internal/offline_download/transmission/client.go
@@ -150,7 +150,13 @@ func (t *Transmission) Status(task *tool.DownloadTask) (*tool.Status, error) {
 		Err:       err,
 	}
 	s.Progress = *info.PercentDone * 100
-	s.TotalBytes = int64(*info.SizeWhenDone / 8)
+	if info.Name != nil {
+		s.FileName = *info.Name
+	}
+	if info.SizeWhenDone != nil {
+		s.TotalBytes = int64(*info.SizeWhenDone / 8)
+		s.FileSize = s.TotalBytes
+	}
 
 	switch *info.Status {
 	case transmissionrpc.TorrentStatusCheckWait,
diff --git a/server/handles/task.go b/server/handles/task.go
@@ -27,9 +27,16 @@ type TaskInfo struct {
 	StartTime   *time.Time  `json:"start_time"`
 	EndTime     *time.Time  `json:"end_time"`
 	TotalBytes  int64       `json:"total_bytes"`
+	FileName    string      `json:"file_name,omitempty"`
+	FileSize    int64       `json:"file_size,omitempty"`
 	Error       string      `json:"error"`
 }
 
+type taskFileInfo interface {
+	GetFileName() string
+	GetFileSize() int64
+}
+
 func getTaskInfo[T task.TaskExtensionInfo](task T) TaskInfo {
 	errMsg := ""
 	if task.GetErr() != nil {
@@ -46,6 +53,12 @@ func getTaskInfo[T task.TaskExtensionInfo](task T) TaskInfo {
 		creatorName = task.GetCreator().Username
 		creatorRole = task.GetCreator().Role
 	}
+	fileName := ""
+	fileSize := int64(0)
+	if taskWithFileInfo, ok := any(task).(taskFileInfo); ok {
+		fileName = taskWithFileInfo.GetFileName()
+		fileSize = taskWithFileInfo.GetFileSize()
+	}
 	return TaskInfo{
 		ID:          task.GetID(),
 		Name:        task.GetName(),
@@ -57,6 +70,8 @@ func getTaskInfo[T task.TaskExtensionInfo](task T) TaskInfo {
 		StartTime:   task.GetStartTime(),
 		EndTime:     task.GetEndTime(),
 		TotalBytes:  task.GetTotalBytes(),
+		FileName:    fileName,
+		FileSize:    fileSize,
 		Error:       errMsg,
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -126,8 +126,10 @@ func (p Cloud115) Status(task tool.DownloadTask) (*tool.Status, error) {`
`126`	`126`	`s.Status = t.GetStatus()`
`127`	`127`	`s.Completed = t.IsDone()`
`128`	`128`	`s.TotalBytes = t.Size`
	`129`	`+ s.FileName = t.Name`
	`130`	`+ s.FileSize = t.Size`
`129`	`131`	`if t.IsFailed() {`
`130`		`- s.Err = fmt.Errorf(t.GetStatus())`
	`132`	`+ s.Err = fmt.Errorf("%s", t.GetStatus())`
`131`	`133`	`}`
`132`	`134`	`return s, nil`
`133`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,8 +123,10 @@ func (o Open115) Status(task tool.DownloadTask) (*tool.Status, error) {`
`123`	`123`	`s.Status = t.GetStatus()`
`124`	`124`	`s.Completed = t.IsDone()`
`125`	`125`	`s.TotalBytes = t.Size`
	`126`	`+ s.FileName = t.Name`
	`127`	`+ s.FileSize = t.Size`
`126`	`128`	`if t.IsFailed() {`
`127`		`- s.Err = fmt.Errorf(t.GetStatus())`
	`129`	`+ s.Err = fmt.Errorf("%s", t.GetStatus())`
`128`	`130`	`}`
`129`	`131`	`return s, nil`
`130`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,11 +79,13 @@ func (s SimpleHttp) Run(task *tool.DownloadTask) error {`
`79`	`79`	`filename = fmt.Sprintf("%s-%d-%x", filename, time.Now().UnixMilli(), rand.Uint32())`
`80`	`80`	`}`
`81`	`81`	`fileSize := resp.ContentLength`
	`82`	`+ task.SetFileInfo(filename, fileSize)`
`82`	`83`	`if streamPut {`
`83`	`84`	`if fileSize == 0 {`
`84`	`85`	`start, end, _ := http_range.ParseContentRange(resp.Header.Get("Content-Range"))`
`85`	`86`	`fileSize = start + end`
`86`	`87`	`}`
	`88`	`+ task.SetFileInfo(filename, fileSize)`
`87`	`89`	`task.SetTotalBytes(fileSize)`
`88`	`90`	`task.TempDir = filename`
`89`	`91`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -123,13 +123,15 @@ func (p PikPak) Status(task tool.DownloadTask) (*tool.Status, error) {`
`123`	`123`	`if t.ID == task.GID {`
`124`	`124`	`s.Progress = float64(t.Progress)`
`125`	`125`	`s.Status = t.Message`
	`126`	`+ s.FileName = t.FileName`
`126`	`127`	`s.Completed = (t.Phase == "PHASE_TYPE_COMPLETE")`
`127`	`128`	`s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)`
`128`	`129`	`if err != nil {`
`129`	`130`	`s.TotalBytes = 0`
`130`	`131`	`}`
	`132`	`+ s.FileSize = s.TotalBytes`
`131`	`133`	`if t.Phase == "PHASE_TYPE_ERROR" {`
`132`		`- s.Err = fmt.Errorf(t.Message)`
	`134`	`+ s.Err = fmt.Errorf("%s", t.Message)`
`133`	`135`	`}`
`134`	`136`	`return s, nil`
`135`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,11 +124,13 @@ func (t Thunder) Status(task tool.DownloadTask) (*tool.Status, error) {`
`124`	`124`	`if t.ID == task.GID {`
`125`	`125`	`s.Progress = float64(t.Progress)`
`126`	`126`	`s.Status = t.Message`
	`127`	`+ s.FileName = t.FileName`
`127`	`128`	`s.Completed = (t.Phase == "PHASE_TYPE_COMPLETE")`
`128`	`129`	`s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)`
`129`	`130`	`if err != nil {`
`130`	`131`	`s.TotalBytes = 0`
`131`	`132`	`}`
	`133`	`+ s.FileSize = s.TotalBytes`
`132`	`134`	`if t.Phase == "PHASE_TYPE_ERROR" {`
`133`	`135`	`s.Err = errors.New(t.Message)`
`134`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,11 +151,13 @@ func (t ThunderBrowser) Status(task tool.DownloadTask) (*tool.Status, error) {`
`151`	`151`	`if t.ID == task.GID {`
`152`	`152`	`s.Progress = float64(t.Progress)`
`153`	`153`	`s.Status = t.Message`
	`154`	`+ s.FileName = t.FileName`
`154`	`155`	`s.Completed = t.Phase == "PHASE_TYPE_COMPLETE"`
`155`	`156`	`s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)`
`156`	`157`	`if err != nil {`
`157`	`158`	`s.TotalBytes = 0`
`158`	`159`	`}`
	`160`	`+ s.FileSize = s.TotalBytes`
`159`	`161`	`if t.Phase == "PHASE_TYPE_ERROR" {`
`160`	`162`	`s.Err = errors.New(t.Message)`
`161`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,11 +118,13 @@ func (t ThunderX) Status(task tool.DownloadTask) (*tool.Status, error) {`
`118`	`118`	`if t.ID == task.GID {`
`119`	`119`	`s.Progress = float64(t.Progress)`
`120`	`120`	`s.Status = t.Message`
	`121`	`+ s.FileName = t.FileName`
`121`	`122`	`s.Completed = t.Phase == "PHASE_TYPE_COMPLETE"`
`122`	`123`	`s.TotalBytes, err = strconv.ParseInt(t.FileSize, 10, 64)`
`123`	`124`	`if err != nil {`
`124`	`125`	`s.TotalBytes = 0`
`125`	`126`	`}`
	`127`	`+ s.FileSize = s.TotalBytes`
`126`	`128`	`if t.Phase == "PHASE_TYPE_ERROR" {`
`127`	`129`	`s.Err = errors.New(t.Message)`
`128`	`130`	`}`