Merge branch 'main' into feat/advanced-transfer-seeds

- Keep storage-to-tool identity in the offline tool package.
- Share settings persistence, tool initialization, and storage admission across handlers.
- Preserve endpoint payloads and unsupported-storage diagnostics with focused tests.

Co-authored-by: nostalume <nostalucent@gmail.com>
Co-authored-by: Codex <267193182+codex@users.noreply.github.com>

.github/workflows/beta_release.yml

@@ -136,7 +136,7 @@ jobs:
           musl-base-url: "https://github.com/OpenListTeam/musl-compilers/releases/latest/download/"
           x-flags: |
             github.com/OpenListTeam/OpenList/v4/internal/conf.BuiltAt=$built_at
-            github.com/OpenListTeam/OpenList/v4/internal/conf.GitAuthor=The OpenList Projects Contributors <noreply@openlist.team>
+            github.com/OpenListTeam/OpenList/v4/internal/conf.GitAuthor=The OpenList Projects Contributors <noreply@oplist.org>
             github.com/OpenListTeam/OpenList/v4/internal/conf.GitCommit=$git_commit
             github.com/OpenListTeam/OpenList/v4/internal/conf.Version=$tag
             github.com/OpenListTeam/OpenList/v4/internal/conf.WebVersion=rolling

.github/workflows/build.yml

@@ -52,7 +52,7 @@ jobs:
           out-dir: build
           x-flags: |
             github.com/OpenListTeam/OpenList/v4/internal/conf.BuiltAt=$built_at
-            github.com/OpenListTeam/OpenList/v4/internal/conf.GitAuthor=The OpenList Projects Contributors <noreply@openlist.team>
+            github.com/OpenListTeam/OpenList/v4/internal/conf.GitAuthor=The OpenList Projects Contributors <noreply@oplist.org>
             github.com/OpenListTeam/OpenList/v4/internal/conf.GitCommit=$git_commit
             github.com/OpenListTeam/OpenList/v4/internal/conf.Version=$tag
             github.com/OpenListTeam/OpenList/v4/internal/conf.WebVersion=rolling

build.sh

@@ -1,7 +1,7 @@
 set -e
 appName="openlist"
 builtAt="$(date +'%F %T %z')"
-gitAuthor="The OpenList Projects Contributors <noreply@openlist.team>"
+gitAuthor="The OpenList Projects Contributors <noreply@oplist.org>"
 gitCommit=$(git log --pretty=format:"%h" -1)
 
 # Set frontend repository, default to OpenListTeam/OpenList-Frontend

drivers/115/seed_rapid.go

@@ -0,0 +1,74 @@
+package _115
+
+import (
+	"context"
+	"strings"
+
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/http_range"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+)
+
+// RapidHashAlgos 返回 115 支持的秒传哈希算法（SHA1）
+func (d *Pan115) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.SHA1}
+}
+
+// RapidHashNeedsPieces 115 不需要分片哈希
+func (d *Pan115) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 SHA1 哈希尝试秒传。
+//
+// 115 的秒传协议除了整文件 SHA1，还需要文件头部 128KB 的 SHA1（pre_hash），
+// 因此当内容源可用时会打开它来计算前置哈希；内容不可用时无法秒传。
+func (d *Pan115) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	fullHash := strings.ToUpper(req.Whole.GetHash(utils.SHA1))
+	if len(fullHash) != utils.SHA1.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+	if req.Open == nil {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	src, err := req.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer src.Close()
+
+	const PreHashSize int64 = 128 * utils.KB
+	hashSize := PreHashSize
+	if req.Size < PreHashSize {
+		hashSize = req.Size
+	}
+	reader, err := src.RangeRead(http_range.Range{Start: 0, Length: hashSize})
+	if err != nil {
+		return nil, err
+	}
+	preHash, err := utils.HashReader(utils.SHA1, reader)
+	if err != nil {
+		return nil, err
+	}
+	preHash = strings.ToUpper(preHash)
+
+	fastInfo, err := d.rapidUpload(req.Size, req.Name, dstDir.GetID(), preHash, fullHash, src)
+	if err != nil {
+		return nil, err
+	}
+	matched, err := fastInfo.Ok()
+	if err != nil {
+		return nil, err
+	}
+	if !matched {
+		return nil, errs.ErrRapidUploadFailed
+	}
+	f, err := d.getNewFileByPickCode(fastInfo.PickCode)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}

drivers/115_open/driver.go

@@ -171,11 +171,22 @@ func (d *Open115) Get(ctx context.Context, path string) (model.Obj, error) {
 	path = stdpath.Join(d.parentPath, path)
 	resp, err := d.client.GetFolderInfoByPath(ctx, path)
 	if err != nil {
+		// SDK-level "object not found" (empty array response from API)
 		if errors.Is(err, sdk.ErrObjectNotFound) {
 			return d.getFromParent(ctx, path, "")
 		}
+		// API-level error response (State=false), treat as not found
+		// since this is a path-lookup that can't resolve the target
+		var apiErr *sdk.Error
+		if errors.As(err, &apiErr) {
+			return nil, errs.ObjectNotFound
+		}
 		return nil, err
 	}
+	// Handle null/empty response (e.g., API returns null data for non-existent path)
+	if resp.FileID == "" {
+		return nil, errs.ObjectNotFound
+	}
 	obj := &Obj{
 		Fid:  resp.FileID,
 		Fn:   resp.FileName,

drivers/115_open/upload.go

@@ -3,6 +3,7 @@ package _115_open
 import (
 	"context"
 	"encoding/base64"
+	"errors"
 	"io"
 	"time"
 
@@ -70,6 +71,19 @@ func (d *Open115) singleUpload(ctx context.Context, tempF model.File, tokenResp
 // 	} `json:"data"`
 // }
 
+// retryExpiredToken retries only the rejected OSS operation, preserving the upload ID.
+func retryExpiredToken(refresh func() error, operation func() error) error {
+	err := operation()
+	var serviceErr oss.ServiceError
+	if !errors.As(err, &serviceErr) || serviceErr.Code != "SecurityTokenExpired" {
+		return err
+	}
+	if err := refresh(); err != nil {
+		return err
+	}
+	return operation()
+}
+
 func (d *Open115) multpartUpload(ctx context.Context, stream model.FileStreamer, up driver.UpdateProgress, tokenResp *sdk.UploadGetTokenResp, initResp *sdk.UploadInitResp) error {
 	ossClient, err := netutil.NewOSSClient(tokenResp.Endpoint, tokenResp.AccessKeyId, tokenResp.AccessKeySecret, oss.SecurityToken(tokenResp.SecurityToken))
 	if err != nil {
@@ -80,7 +94,32 @@ func (d *Open115) multpartUpload(ctx context.Context, stream model.FileStreamer,
 		return err
 	}
 
-	imur, err := bucket.InitiateMultipartUpload(initResp.Object, oss.Sequential())
+	refresh := func() error {
+		if err := d.WaitLimit(ctx); err != nil {
+			return err
+		}
+		token, err := d.client.UploadGetToken(ctx)
+		if err != nil {
+			return err
+		}
+		client, err := netutil.NewOSSClient(token.Endpoint, token.AccessKeyId, token.AccessKeySecret, oss.SecurityToken(token.SecurityToken))
+		if err != nil {
+			return err
+		}
+		newBucket, err := client.Bucket(initResp.Bucket)
+		if err != nil {
+			return err
+		}
+		bucket = newBucket
+		return nil
+	}
+
+	var imur oss.InitiateMultipartUploadResult
+	err = retryExpiredToken(refresh, func() error {
+		var err error
+		imur, err = bucket.InitiateMultipartUpload(initResp.Object, oss.Sequential(), oss.WithContext(ctx))
+		return err
+	})
 	if err != nil {
 		return err
 	}
@@ -109,13 +148,17 @@ func (d *Open115) multpartUpload(ctx context.Context, stream model.FileStreamer,
 			return err
 		}
 		err = retry.Do(func() error {
-			rd.Seek(0, io.SeekStart)
-			part, err := bucket.UploadPart(imur, driver.NewLimitedUploadStream(ctx, rd), partSize, int(i))
-			if err != nil {
-				return err
-			}
-			parts[i-1] = part
-			return nil
+			return retryExpiredToken(refresh, func() error {
+				if _, err := rd.Seek(0, io.SeekStart); err != nil {
+					return err
+				}
+				part, err := bucket.UploadPart(imur, driver.NewLimitedUploadStream(ctx, rd), partSize, int(i), oss.WithContext(ctx))
+				if err != nil {
+					return err
+				}
+				parts[i-1] = part
+				return nil
+			})
 		},
 			retry.Context(ctx),
 			retry.Attempts(3),
@@ -134,14 +177,16 @@ func (d *Open115) multpartUpload(ctx context.Context, stream model.FileStreamer,
 		up(float64(offset) * 100 / float64(fileSize))
 	}
 
-	// callbackRespBytes := make([]byte, 1024)
-	_, err = bucket.CompleteMultipartUpload(
-		imur,
-		parts,
-		oss.Callback(base64.StdEncoding.EncodeToString([]byte(initResp.Callback.Value.Callback))),
-		oss.CallbackVar(base64.StdEncoding.EncodeToString([]byte(initResp.Callback.Value.CallbackVar))),
-		// oss.CallbackResult(&callbackRespBytes),
-	)
+	err = retryExpiredToken(refresh, func() error {
+		_, err := bucket.CompleteMultipartUpload(
+			imur,
+			parts,
+			oss.Callback(base64.StdEncoding.EncodeToString([]byte(initResp.Callback.Value.Callback))),
+			oss.CallbackVar(base64.StdEncoding.EncodeToString([]byte(initResp.Callback.Value.CallbackVar))),
+			oss.WithContext(ctx),
+		)
+		return err
+	})
 	if err != nil {
 		return err
 	}

drivers/123/seed_rapid.go

@@ -0,0 +1,73 @@
+package _123
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/OpenListTeam/OpenList/v4/drivers/base"
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+	"github.com/go-resty/resty/v2"
+)
+
+// RapidHashAlgos 返回 123 云盘支持的秒传哈希算法（MD5）
+func (d *Pan123) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.MD5}
+}
+
+// RapidHashNeedsPieces 123 云盘不需要分片哈希
+func (d *Pan123) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 MD5（Etag）哈希尝试秒传。
+//
+// 123 的秒传即「上传请求返回 reuse=true」，无需真正传输内容。
+func (d *Pan123) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	etag := req.Whole.GetHash(utils.MD5)
+	if len(etag) < utils.MD5.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	duplicate := 0
+	if overwrite {
+		duplicate = 2
+	}
+	data := base.Json{
+		"driveId":      0,
+		"duplicate":    duplicate,
+		"etag":         strings.ToLower(etag),
+		"fileName":     req.Name,
+		"parentFileId": dstDir.GetID(),
+		"size":         req.Size,
+		"type":         0,
+	}
+
+	var resp UploadResp
+	_, err := d.Request(UploadRequest, http.MethodPost, func(r *resty.Request) {
+		r.SetBody(data).SetContext(ctx)
+	}, &resp)
+	if err != nil {
+		return nil, err
+	}
+	// reuse=true 或未返回上传 Key 均视为秒传成功
+	if !resp.Data.Reuse && resp.Data.Key != "" {
+		return nil, errs.ErrHashMismatch
+	}
+
+	return &model.ObjThumb{
+		Object: model.Object{
+			ID:       strconv.FormatInt(resp.Data.FileId, 10),
+			Name:     req.Name,
+			Size:     req.Size,
+			Modified: time.Now(),
+			IsFolder: false,
+			HashInfo: utils.NewHashInfo(utils.MD5, strings.ToLower(etag)),
+		},
+	}, nil
+}

drivers/123_open/seed_rapid.go

@@ -0,0 +1,55 @@
+package _123_open
+
+import (
+	"context"
+	"path"
+	"strconv"
+	"time"
+
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+)
+
+// RapidHashAlgos 返回 123 开放平台支持的秒传哈希算法（SHA1）
+func (d *Open123) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.SHA1}
+}
+
+// RapidHashNeedsPieces 123 开放平台不需要分片哈希
+func (d *Open123) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 SHA1 哈希尝试秒传
+func (d *Open123) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	sha1Hash := req.Whole.GetHash(utils.SHA1)
+	if len(sha1Hash) < utils.SHA1.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	parentID, err := strconv.ParseInt(dstDir.GetID(), 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := d.sha1Reuse(parentID, req.Name, sha1Hash, req.Size, 1)
+	if err != nil {
+		return nil, err
+	}
+	if !resp.Data.Reuse {
+		return nil, errs.ErrHashMismatch
+	}
+
+	return &model.ObjThumb{
+		Object: model.Object{
+			ID:       strconv.FormatInt(resp.Data.FileID, 10),
+			Name:     req.Name,
+			Size:     req.Size,
+			IsFolder: false,
+			Path:     path.Join(dstDir.GetPath(), req.Name),
+			Modified: time.Now(),
+		},
+	}, nil
+}

drivers/189/torrent.go

@@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
-	"strings"
 
 	"github.com/OpenListTeam/OpenList/v4/internal/model"
 	"github.com/OpenListTeam/OpenList/v4/pkg/torrent"
@@ -15,12 +14,8 @@ import (
 
 // GenerateTorrent 根据上传过程中收集的哈希信息生成包含 CAS 扩展的 torrent 文件
 func GenerateTorrent(fileName string, fileSize int64, fileMD5 string, sliceMD5s []string, sliceSize int64, pieceHashes []byte) ([]byte, error) {
-	// 计算 sliceMD5
-	sliceMD5 := fileMD5
-	if len(sliceMD5s) > 1 {
-		joined := strings.Join(sliceMD5s, "\n")
-		sliceMD5 = strings.ToUpper(torrent.GetMD5Str(joined))
-	}
+	// 计算 sliceMD5（统一走规范实现）
+	sliceMD5 := torrent.SliceMD5FromPieces(sliceMD5s, fileMD5)
 
 	t := torrent.NewTorrent(fileName, fileSize, fileMD5)
 	t.Info.PieceLength = sliceSize
@@ -30,7 +25,7 @@ func GenerateTorrent(fileName string, fileSize int64, fileMD5 string, sliceMD5s
 		SliceMD5:  sliceMD5,
 		SliceMD5s: sliceMD5s,
 		SliceSize: sliceSize,
-		Cloud:     "189",
+		Cloud:     torrent.Cloud189,
 	})
 
 	return t.Encode()
@@ -95,7 +90,7 @@ func ComputeTorrentFromReader(reader io.Reader, fileName string, fileSize int64,
 		sliceSize = torrent.DefaultPieceSize
 	}
 
-	hw := torrent.NewHashWriter(sliceSize, sliceSize)
+	hw := torrent.NewHashWriter(sliceSize, sliceSize, fileSize)
 
 	buf := make([]byte, 32*1024)
 	for {

drivers/189_tv/seed_rapid.go

@@ -0,0 +1,35 @@
+package _189_tv
+
+import (
+	"context"
+
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+)
+
+// RapidHashAlgos 返回 189 电视支持的秒传哈希算法（MD5）
+func (d *Cloud189TV) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.MD5}
+}
+
+// RapidHashNeedsPieces 189 电视不需要分片哈希
+func (d *Cloud189TV) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 MD5 哈希尝试秒传
+func (d *Cloud189TV) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	md5Hash := req.Whole.GetHash(utils.MD5)
+	if len(md5Hash) < utils.MD5.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	stream := driver.NewSeedHashStream(req)
+	obj, err := d.RapidUpload(ctx, dstDir, stream, d.isFamily(), overwrite)
+	if err != nil {
+		return nil, err
+	}
+	return obj, nil
+}

drivers/189pc/seed_rapid.go

@@ -0,0 +1,35 @@
+package _189pc
+
+import (
+	"context"
+
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+)
+
+// RapidHashAlgos 返回 189pc 支持的秒传哈希算法（MD5）
+func (d *Cloud189PC) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.MD5}
+}
+
+// RapidHashNeedsPieces 189pc 的 CAS 秒传依赖分片 MD5
+func (d *Cloud189PC) RapidHashNeedsPieces() bool {
+	return true
+}
+
+// RapidUploadByHashes 使用种子中的 MD5 哈希尝试秒传
+func (d *Cloud189PC) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	md5Hash := req.Whole.GetHash(utils.MD5)
+	if len(md5Hash) < utils.MD5.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	stream := driver.NewSeedHashStream(req)
+	obj, err := d.RapidUpload(ctx, dstDir, stream, d.isFamily(), overwrite)
+	if err != nil {
+		return nil, err
+	}
+	return obj, nil
+}

drivers/189pc/torrent.go

@@ -7,7 +7,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
-	"net/url"
 	"strings"
 	"time"
 
@@ -28,12 +27,8 @@ import (
 // fileName: 文件名
 // fileSize: 文件大小
 func GenerateTorrent(fileName string, fileSize int64, fileMD5 string, sliceMD5s []string, sliceSize int64, pieceHashes []byte) ([]byte, error) {
-	// 计算 sliceMD5
-	sliceMD5 := fileMD5
-	if len(sliceMD5s) > 1 {
-		joined := strings.Join(sliceMD5s, "\n")
-		sliceMD5 = strings.ToUpper(torrent.GetMD5Str(joined))
-	}
+	// 计算 sliceMD5（统一走规范实现）
+	sliceMD5 := torrent.SliceMD5FromPieces(sliceMD5s, fileMD5)
 
 	t := torrent.NewTorrent(fileName, fileSize, fileMD5)
 	t.Info.PieceLength = sliceSize
@@ -43,7 +38,7 @@ func GenerateTorrent(fileName string, fileSize int64, fileMD5 string, sliceMD5s
 		SliceMD5:  sliceMD5,
 		SliceMD5s: sliceMD5s,
 		SliceSize: sliceSize,
-		Cloud:     "189",
+		Cloud:     torrent.Cloud189,
 	})
 
 	return t.Encode()
@@ -69,101 +64,18 @@ func (y *Cloud189PC) RapidUploadFromTorrent(ctx context.Context, dstDir model.Ob
 	fileName := t.Info.Name
 	fileSize := t.GetTotalSize()
 
-	// 统一 MD5 为大写（与正常上传保持一致，天翼云盘要求大写）
-	fileMD5Upper := strings.ToUpper(cas.FileMD5)
-
-	// 优先使用 torrent 中嵌入的分片大小，与生成时保持一致
-	sliceSize := cas.SliceSize
-	if sliceSize <= 0 {
-		sliceSize = partSize(fileSize)
+	// 优先使用 torrent 中嵌入的分片 MD5 与大写整文件 MD5
+	fileMD5 := strings.ToUpper(cas.FileMD5)
+	sliceMD5s := make([]string, len(cas.SliceMD5s))
+	for i, s := range cas.SliceMD5s {
+		sliceMD5s[i] = strings.ToUpper(s)
 	}
 
-	// 计算 sliceMd5（与上传时一致的算法）
-	// 优先使用 torrent 中已有的 SliceMD5；仅当有多分片列表时才重新计算
-	sliceMd5Hex := strings.ToUpper(cas.SliceMD5)
-	if sliceMd5Hex == "" {
-		sliceMd5Hex = fileMD5Upper
-	}
-	if len(cas.SliceMD5s) > 1 {
-		// 分片 MD5 也需要统一大写后再拼接计算
-		upperSliceMD5s := make([]string, len(cas.SliceMD5s))
-		for i, s := range cas.SliceMD5s {
-			upperSliceMD5s[i] = strings.ToUpper(s)
-		}
-		sliceMd5Hex = strings.ToUpper(utils.GetMD5EncodeStr(strings.Join(upperSliceMD5s, "\n")))
-	}
-
-	// 使用与 Web 端一致的三步秒传流程
-	fullUrl := "https://upload.cloud.189.cn"
-	if isFamily {
-		fullUrl += "/family"
-	} else {
-		fullUrl += "/person"
-	}
-
-	// Step 1: initMultiUpload（不传 fileMd5/sliceMd5，只传 lazyCheck）
-	initParams := Params{
-		"parentFolderId": dstDir.GetID(),
-		"fileName":       url.QueryEscape(fileName),
-		"fileSize":       fmt.Sprint(fileSize),
-		"sliceSize":      fmt.Sprint(sliceSize),
-		"lazyCheck":      "1",
-	}
-	if isFamily {
-		initParams.Set("familyId", y.FamilyID)
-	}
-
-	var uploadInfo InitMultiUploadResp
-	_, err = y.request(fullUrl+"/initMultiUpload", "GET", func(req *resty.Request) {
-		req.SetContext(ctx)
-	}, initParams, &uploadInfo, isFamily)
+	// 复用统一的 CAS 秒传核心实现
+	respObj, err := y.rapidUploadByCAS(ctx, dstDir, fileName, fileSize, fileMD5, sliceMD5s, cas.SliceSize, overwrite)
 	if err != nil {
-		return nil, fmt.Errorf("initMultiUpload 失败: %w", err)
-	}
-
-	uploadFileId := uploadInfo.Data.UploadFileID
-
-	// Step 2: checkTransSecond（用 fileMd5 + sliceMd5 + uploadFileId 检查秒传）
-	checkParams := Params{
-		"fileMd5":      fileMD5Upper,
-		"sliceMd5":     sliceMd5Hex,
-		"uploadFileId": uploadFileId,
-	}
-
-	var checkResp struct {
-		Data struct {
-			FileDataExists int `json:"fileDataExists"`
-		} `json:"data"`
-	}
-	_, err = y.request(fullUrl+"/checkTransSecond", "GET", func(req *resty.Request) {
-		req.SetContext(ctx)
-	}, checkParams, &checkResp, isFamily)
-	if err != nil {
-		utils.Log.Errorf("[RapidUpload] checkTransSecond 失败: uploadFileId=%s, err=%v", uploadFileId, err)
-		return nil, fmt.Errorf("秒传检查失败: %w", err)
-	}
-
-	if checkResp.Data.FileDataExists != 1 {
-		return nil, fmt.Errorf("秒传失败：云端不存在该文件（fileMD5=%s, sliceMD5=%s, size=%d）", fileMD5Upper, sliceMd5Hex, fileSize)
-	}
-
-	// Step 3: commitMultiUploadFile（传 fileMd5 + sliceMd5）
-
-	var resp CommitMultiUploadFileResp
-	commitParams := Params{
-		"uploadFileId": uploadFileId,
-		"fileMd5":      fileMD5Upper,
-		"sliceMd5":     sliceMd5Hex,
-		"lazyCheck":    "1",
-		"opertype":     IF(overwrite, "3", "1"),
-	}
-
-	_, err = y.request(fullUrl+"/commitMultiUploadFile", "GET", func(req *resty.Request) {
-		req.SetContext(ctx)
-	}, commitParams, &resp, isFamily)
-	if err != nil {
-		utils.Log.Errorf("[RapidUpload] commitMultiUploadFile 失败: uploadFileId=%s, err=%v", uploadFileId, err)
-		return nil, fmt.Errorf("提交上传失败: %w", err)
+		utils.Log.Errorf("[RapidUpload] 秒传失败: fileMD5=%s, err=%v", fileMD5, err)
+		return nil, err
 	}
 
 	// 秒传成功后，将 torrent 文件上传到目标目录（异步，不影响秒传结果）
@@ -196,7 +108,7 @@ func (y *Cloud189PC) RapidUploadFromTorrent(ctx context.Context, dstDir model.Ob
 		}()
 	}
 
-	return resp.toFile(), nil
+	return respObj, nil
 }
 
 // ComputeTorrentFromReader 从 io.Reader 计算并生成 torrent 文件
@@ -206,7 +118,7 @@ func ComputeTorrentFromReader(reader io.Reader, fileName string, fileSize int64,
 		sliceSize = torrent.DefaultPieceSize
 	}
 
-	hw := torrent.NewHashWriter(sliceSize, sliceSize)
+	hw := torrent.NewHashWriter(sliceSize, sliceSize, fileSize)
 
 	buf := make([]byte, 32*1024)
 	for {
@@ -259,12 +171,8 @@ func InjectCASIntoTorrent(torrentData []byte, fileMD5 string, sliceMD5s []string
 		return nil, fmt.Errorf("解析 torrent 失败: %w", err)
 	}
 
-	// 计算 sliceMD5
-	sliceMD5 := fileMD5
-	if len(sliceMD5s) > 1 {
-		joined := strings.Join(sliceMD5s, "\n")
-		sliceMD5 = strings.ToUpper(torrent.GetMD5Str(joined))
-	}
+	// 计算 sliceMD5（统一走规范实现）
+	sliceMD5 := torrent.SliceMD5FromPieces(sliceMD5s, fileMD5)
 
 	// 注入 CAS 信息
 	t.SetCASInfo(&torrent.CASInfo{
@@ -272,7 +180,7 @@ func InjectCASIntoTorrent(torrentData []byte, fileMD5 string, sliceMD5s []string
 		SliceMD5:  sliceMD5,
 		SliceMD5s: sliceMD5s,
 		SliceSize: sliceSize,
-		Cloud:     "189",
+		Cloud:     torrent.Cloud189,
 	})
 
 	// 同时更新 info 中的 md5sum 字段

drivers/189pc/utils.go

@@ -1329,6 +1329,102 @@ func (y *Cloud189PC) OldUploadCommit(ctx context.Context, fileCommitUrl string,
 	return resp.toFile(), nil
 }
 
+// rapidUploadByCAS 使用 MD5 + 分片 MD5（CAS）执行天翼云盘秒传。
+//
+// 流程与 Web 端一致：
+//  1. initMultiUpload（仅传 lazyCheck=1）
+//  2. checkTransSecond（用 fileMd5 + sliceMd5 检查云端是否已存在文件数据）
+//  3. commitMultiUploadFile（提交并返回文件对象）
+func (y *Cloud189PC) rapidUploadByCAS(ctx context.Context, dstDir model.Obj, fileName string, fileSize int64, fileMD5 string, sliceMD5s []string, sliceSize int64, overwrite bool) (model.Obj, error) {
+	isFamily := y.isFamily()
+
+	// 统一 MD5 为大写（天翼云盘要求大写）
+	fileMD5Upper := strings.ToUpper(fileMD5)
+
+	// 优先使用传入的分片大小，否则按文件大小推导
+	if sliceSize <= 0 {
+		sliceSize = partSize(fileSize)
+	}
+
+	// 计算 sliceMd5（与上传时一致的算法）
+	sliceMd5Hex := fileMD5Upper
+	if len(sliceMD5s) > 1 {
+		upperSliceMD5s := make([]string, len(sliceMD5s))
+		for i, s := range sliceMD5s {
+			upperSliceMD5s[i] = strings.ToUpper(s)
+		}
+		sliceMd5Hex = strings.ToUpper(utils.GetMD5EncodeStr(strings.Join(upperSliceMD5s, "\n")))
+	} else if len(sliceMD5s) == 1 {
+		sliceMd5Hex = strings.ToUpper(sliceMD5s[0])
+	}
+
+	fullUrl := "https://upload.cloud.189.cn"
+	if isFamily {
+		fullUrl += "/family"
+	} else {
+		fullUrl += "/person"
+	}
+
+	// Step 1: initMultiUpload（不传 fileMd5/sliceMd5，只传 lazyCheck）
+	initParams := Params{
+		"parentFolderId": dstDir.GetID(),
+		"fileName":       url.QueryEscape(fileName),
+		"fileSize":       fmt.Sprint(fileSize),
+		"sliceSize":      fmt.Sprint(sliceSize),
+		"lazyCheck":      "1",
+	}
+	if isFamily {
+		initParams.Set("familyId", y.FamilyID)
+	}
+
+	var uploadInfo InitMultiUploadResp
+	if _, err := y.request(fullUrl+"/initMultiUpload", "GET", func(req *resty.Request) {
+		req.SetContext(ctx)
+	}, initParams, &uploadInfo, isFamily); err != nil {
+		return nil, fmt.Errorf("initMultiUpload 失败: %w", err)
+	}
+	uploadFileId := uploadInfo.Data.UploadFileID
+
+	// Step 2: checkTransSecond（用 fileMd5 + sliceMd5 + uploadFileId 检查秒传）
+	checkParams := Params{
+		"fileMd5":      fileMD5Upper,
+		"sliceMd5":     sliceMd5Hex,
+		"uploadFileId": uploadFileId,
+	}
+
+	var checkResp struct {
+		Data struct {
+			FileDataExists int `json:"fileDataExists"`
+		} `json:"data"`
+	}
+	if _, err := y.request(fullUrl+"/checkTransSecond", "GET", func(req *resty.Request) {
+		req.SetContext(ctx)
+	}, checkParams, &checkResp, isFamily); err != nil {
+		return nil, fmt.Errorf("秒传检查失败: %w", err)
+	}
+	if checkResp.Data.FileDataExists != 1 {
+		return nil, fmt.Errorf("秒传失败：云端不存在该文件（fileMD5=%s, sliceMD5=%s, size=%d）", fileMD5Upper, sliceMd5Hex, fileSize)
+	}
+
+	// Step 3: commitMultiUploadFile（传 fileMd5 + sliceMd5）
+	commitParams := Params{
+		"uploadFileId": uploadFileId,
+		"fileMd5":      fileMD5Upper,
+		"sliceMd5":     sliceMd5Hex,
+		"lazyCheck":    "1",
+		"opertype":     IF(overwrite, "3", "1"),
+	}
+
+	var resp CommitMultiUploadFileResp
+	if _, err := y.request(fullUrl+"/commitMultiUploadFile", "GET", func(req *resty.Request) {
+		req.SetContext(ctx)
+	}, commitParams, &resp, isFamily); err != nil {
+		return nil, fmt.Errorf("提交上传失败: %w", err)
+	}
+
+	return resp.toFile(), nil
+}
+
 func (y *Cloud189PC) isFamily() bool {
 	return y.Type == "family"
 }

drivers/alias/driver.go

@@ -328,7 +328,6 @@ func (d *Alias) Link(ctx context.Context, file model.Obj, args model.LinkArgs) (
 		return nil, err
 	}
 	resultLink := link.Clone() // 复制一份，避免修改到原始link
-	resultLink.Expiration = nil
 	if args.Redirect {
 		return resultLink, nil
 	}

drivers/alist_v3/driver.go

@@ -95,6 +95,7 @@ func (d *AListV3) List(ctx context.Context, dir model.Obj, args model.ListArgs)
 		file := model.ObjThumb{
 			Object: model.Object{
 				Name:     f.Name,
+				Path:     path.Join(dir.GetPath(), f.Name),
 				Modified: f.Modified,
 				Ctime:    f.Created,
 				Size:     f.Size,

drivers/alist_v3/driver_test.go

@@ -0,0 +1,65 @@
+package alist_v3
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/OpenListTeam/OpenList/v4/drivers/base"
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/go-resty/resty/v2"
+)
+
+// TestListSetsChildPaths descends two levels the way op.Get does, feeding an
+// object from one listing back into List as dir. Without a Path on that object
+// the driver asks upstream for "", which a real server answers with its own
+// root -- hence the fake upstream's fallback, and the endless self-similar tree.
+func TestListSetsChildPaths(t *testing.T) {
+	tree := map[string][]ObjResp{
+		"/":               {{Name: "root-marker", IsDir: true}},
+		"/drive":          {{Name: "concerts", IsDir: true}},
+		"/drive/concerts": {{Name: "show.mkv"}},
+	}
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var req ListReq
+		_ = json.NewDecoder(r.Body).Decode(&req)
+		content, ok := tree[req.Path]
+		if !ok {
+			content = tree["/"]
+		}
+		w.Header().Set("Content-Type", "application/json") // resty only unmarshals JSON
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"code": 200, "message": "success",
+			"data": map[string]any{"content": content, "total": len(content)},
+		})
+	}))
+	t.Cleanup(srv.Close)
+
+	// conf.Conf is nil outside a booted server, so base.InitClient() is unusable.
+	prev := base.RestyClient
+	base.RestyClient = resty.New().SetTimeout(5 * time.Second)
+	t.Cleanup(func() { base.RestyClient = prev })
+
+	d := &AListV3{Addition: Addition{
+		RootPath: driver.RootPath{RootFolderPath: "/drive"},
+		Address:  srv.URL,
+	}}
+	dir := model.Obj(&model.Object{Path: "/drive", IsFolder: true})
+	for _, want := range []string{"/drive/concerts", "/drive/concerts/show.mkv"} {
+		objs, err := d.List(context.Background(), dir, model.ListArgs{})
+		if err != nil {
+			t.Fatalf("List(%q): %v", dir.GetPath(), err)
+		}
+		if len(objs) != 1 {
+			t.Fatalf("List(%q) returned %d objects, want 1", dir.GetPath(), len(objs))
+		}
+		if got := objs[0].GetPath(); got != want {
+			t.Fatalf("child of %q has path %q, want %q", dir.GetPath(), got, want)
+		}
+		dir = objs[0]
+	}
+}

drivers/aliyundrive_open/seed_rapid.go

@@ -0,0 +1,88 @@
+package aliyundrive_open
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/OpenListTeam/OpenList/v4/drivers/base"
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+	"github.com/go-resty/resty/v2"
+)
+
+// RapidHashAlgos 返回阿里云盘支持的秒传哈希算法（SHA1）
+func (d *AliyundriveOpen) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.SHA1}
+}
+
+// RapidHashNeedsPieces 阿里云盘不需要分片哈希
+func (d *AliyundriveOpen) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 SHA1 哈希尝试秒传。
+//
+// 阿里云盘的秒传还需要 proof_code（按 proof range 读取的一段内容），
+// 因此当内容源不可用时无法完成秒传。
+func (d *AliyundriveOpen) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	sha1Hash := req.Whole.GetHash(utils.SHA1)
+	if len(sha1Hash) < utils.SHA1.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+	if req.Open == nil {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	stream, err := req.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer stream.Close()
+
+	proofCode, err := d.calProofCode(stream)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp CreateResp
+	_, err = d.request(ctx, limiterOther, "/adrive/v1.0/openFile/create", http.MethodPost, func(r *resty.Request) {
+		r.SetBody(base.Json{
+			"drive_id":          d.DriveId,
+			"parent_file_id":    dstDir.GetID(),
+			"name":              req.Name,
+			"type":              "file",
+			"check_name_mode":   "auto_rename",
+			"size":              req.Size,
+			"content_hash":      sha1Hash,
+			"content_hash_name": "sha1",
+			"proof_version":     "v1",
+			"proof_code":        proofCode,
+		}).SetResult(&resp)
+	})
+	if err != nil {
+		return nil, err
+	}
+	if !resp.RapidUpload {
+		return nil, errs.ErrHashMismatch
+	}
+
+	if resp.FileId != "" {
+		obj, err := d.completeUpload(ctx, resp.FileId, resp.UploadId)
+		if err != nil {
+			return nil, err
+		}
+		return obj, nil
+	}
+
+	return &model.ObjThumb{
+		Object: model.Object{
+			Name:     req.Name,
+			Size:     req.Size,
+			Modified: time.Now(),
+			IsFolder: false,
+		},
+	}, nil
+}

drivers/baidu_netdisk/seed_rapid.go

@@ -0,0 +1,35 @@
+package baidu_netdisk
+
+import (
+	"context"
+
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+)
+
+// RapidHashAlgos 返回百度网盘支持的秒传哈希算法（MD5）
+func (d *BaiduNetdisk) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*utils.MD5}
+}
+
+// RapidHashNeedsPieces 百度网盘不需要分片哈希
+func (d *BaiduNetdisk) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 MD5 哈希尝试秒传
+func (d *BaiduNetdisk) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	md5Hash := req.Whole.GetHash(utils.MD5)
+	if len(md5Hash) < utils.MD5.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	stream := driver.NewSeedHashStream(req)
+	obj, err := d.PutRapid(ctx, dstDir, stream)
+	if err != nil {
+		return nil, err
+	}
+	return obj, nil
+}

drivers/misskey/util.go

@@ -245,6 +245,7 @@ func mFile2Object(file MFile) *model.ObjThumbURL {
 			Ctime:    ctime,
 			IsFolder: false,
 			Size:     file.Size,
+			HashInfo: utils.NewHashInfo(utils.MD5, file.MD5),
 		},
 		Thumbnail: model.Thumbnail{
 			Thumbnail: file.ThumbnailURL,

drivers/pikpak/seed_rapid.go

@@ -0,0 +1,58 @@
+package pikpak
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"github.com/OpenListTeam/OpenList/v4/drivers/base"
+	"github.com/OpenListTeam/OpenList/v4/internal/driver"
+	"github.com/OpenListTeam/OpenList/v4/internal/errs"
+	"github.com/OpenListTeam/OpenList/v4/internal/model"
+	"github.com/OpenListTeam/OpenList/v4/pkg/utils"
+	hash_extend "github.com/OpenListTeam/OpenList/v4/pkg/utils/hash"
+	"github.com/go-resty/resty/v2"
+)
+
+// RapidHashAlgos 返回 PikPak 支持的秒传哈希算法（GCID）
+func (d *PikPak) RapidHashAlgos() []utils.HashType {
+	return []utils.HashType{*hash_extend.GCID}
+}
+
+// RapidHashNeedsPieces PikPak 不需要分片哈希
+func (d *PikPak) RapidHashNeedsPieces() bool {
+	return false
+}
+
+// RapidUploadByHashes 使用种子中的 GCID 哈希尝试秒传
+func (d *PikPak) RapidUploadByHashes(ctx context.Context, dstDir model.Obj, req *driver.SeedRapidUploadRequest, overwrite bool) (model.Obj, error) {
+	gcid := req.Whole.GetHash(hash_extend.GCID)
+	if len(gcid) < hash_extend.GCID.Width {
+		return nil, errs.ErrUnavailableHash
+	}
+
+	var resp UploadTaskData
+	_, err := d.request("https://api-drive.mypikpak.net/drive/v1/files", http.MethodPost, func(r *resty.Request) {
+		r.SetContext(ctx).SetBody(base.Json{
+			"kind":        "drive#file",
+			"name":        req.Name,
+			"size":        req.Size,
+			"hash":        strings.ToUpper(gcid),
+			"upload_type": "UPLOAD_TYPE_RESUMABLE",
+			"objProvider": base.Json{"provider": "UPLOAD_TYPE_UNKNOWN"},
+			"parent_id":   dstDir.GetID(),
+			"folder_type": "NORMAL",
+		})
+	}, &resp)
+	if err != nil {
+		return nil, err
+	}
+
+	// 秒传成功时不会返回 Resumable
+	if resp.Resumable == nil {
+		file := fileToObj(resp.File)
+		return file, nil
+	}
+
+	return nil, errs.ErrHashMismatch
+}