fix(sync): deduplicate remoteMeta by file ID to prevent deleting valid remote metadata copies

优化同步逻辑

internal/handler/media.go

@@ -660,14 +660,25 @@ func streamHandler(svc *service.Container) gin.HandlerFunc {
 				}
 				return
 			}
-			target, err := svc.EmbyRemote.WebStreamURL(ctx, acct, remoteID)
-			if err != nil {
-				c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
+				target, err := svc.EmbyRemote.WebStreamURL(ctx, acct, remoteID)
+				if err != nil {
+					c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
+					return
+				}
+				// 现代浏览器在 HTTPS 页面中请求不安全源（HTTP 视频流）会直接报 Mixed Content 拦截导致播放失败。
+				// 仅当当前前端请求为 HTTPS 且远程直连目标为 HTTP 时，自动降级通过本机反向代理传输流，避免播放被浏览器阻断；
+				// 其它场景（HTTP 页面访问 HTTP/HTTPS，或 HTTPS 访问 HTTPS）继续 302 直连，最大化节省服务器带宽与流量。
+				if requestIsHTTPS(c) && strings.HasPrefix(strings.ToLower(target), "http://") {
+					if err := svc.Emby.ProxyRemoteVideoStream(ctx, c.Writer, c.Request, mountID, remoteID); err != nil {
+						if !c.Writer.Written() {
+							c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
+						}
+					}
+					return
+				}
+				setRedirectNoStoreHeaders(c)
+				c.Redirect(http.StatusFound, target)
 				return
-			}
-			setRedirectNoStoreHeaders(c)
-			c.Redirect(http.StatusFound, target)
-			return
 		}
 		m, err := svc.Media.GetMedia(ctx, id)
 		if err != nil || m == nil || !mediaVisibleForRequest(c, svc, m) {

internal/service/cloud/clouddrive2.go

@@ -87,15 +87,15 @@ func (p *cloudDrive2Provider) Resolve(ctx context.Context, fileRef string) (*Dir
 	if ref == "/" {
 		return nil, fmt.Errorf("%s: file reference required", p.name)
 	}
-	if p.typ == TypeOpenList && isCloudVideoPlaybackCandidate(ref) {
-		if p.apiBase == nil {
-			return nil, fmt.Errorf("%s: pure 302 playback requires an OpenList API server address; configure server/api_url so /api/fs/get can return raw_url", p.name)
-		}
+	if p.typ == TypeOpenList && p.apiBase != nil {
 		link, err := p.resolveOpenListAPIDirect(ctx, ref)
-		if err != nil {
-			return nil, fmt.Errorf("%s: pure 302 playback requires OpenList raw_url for %s: %w", p.name, ref, err)
+		if err == nil {
+			return link, nil
+		}
+		// API 获取直链失败：非视频文件（元数据）回退到 WebDAV；视频文件报错
+		if isCloudVideoPlaybackCandidate(ref) {
+			return nil, fmt.Errorf("%s: resolve download URL for %s via API failed: %w", p.name, ref, err)
 		}
-		return link, nil
 	}
 	if p.typ == TypeCloudDrive2 && isCloudVideoPlaybackCandidate(ref) {
 		link, err := p.resolveCloudDAVRedirectDirect(ctx, ref)

internal/service/cloud/openlist_list_test.go

@@ -61,9 +61,10 @@ func TestOpenListWebDAVListAndResolve(t *testing.T) {
 	if len(entries) != 1 || entries[0].ID != "/Cloud/Movie.mkv" || entries[0].Size != 1024 {
 		t.Fatalf("entries = %#v", entries)
 	}
+	// Video file: API fails → error (no WebDAV fallback for video)
 	_, err = p.Resolve(context.Background(), entries[0].ID)
-	if err == nil || !strings.Contains(err.Error(), "pure 302 playback requires OpenList raw_url") {
-		t.Fatalf("openlist video resolve should require raw_url instead of WebDAV proxy fallback, err=%v", err)
+	if err == nil || !strings.Contains(err.Error(), "resolve download URL") || !strings.Contains(err.Error(), "via API failed") {
+		t.Fatalf("openlist video resolve should error on API failure, err=%v", err)
 	}
 }
 

internal/service/cloud/openlist_resolve_test.go

@@ -195,10 +195,43 @@ func TestOpenListResolveDoesNotFallbackToWebDAVWhenAPIRawURLFails(t *testing.T)
 		t.Fatal(err)
 	}
 	_, err = p.Resolve(context.Background(), "/Cloud/Movie.mkv")
-	if err == nil || !strings.Contains(err.Error(), "pure 302 playback requires OpenList raw_url") {
-		t.Fatalf("resolve error = %v, want raw_url requirement", err)
+	if err == nil || !strings.Contains(err.Error(), "resolve download URL") || !strings.Contains(err.Error(), "via API failed") {
+		t.Fatalf("resolve error = %v, want API resolve failure", err)
 	}
 	if davSeen {
 		t.Fatal("openlist video resolve fell back to WebDAV after raw_url failure")
 	}
 }
+
+func TestOpenListResolveMetadataUsesAPIInsteadOfWebDAV(t *testing.T) {
+	var gotPath, gotAuth string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath = r.URL.Path
+		gotAuth = r.Header.Get("Authorization")
+		if r.Method != http.MethodPost || r.URL.Path != "/api/fs/get" {
+			t.Fatalf("unexpected request %s %s; metadata should use API, not WebDAV", r.Method, r.URL.Path)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"code":200,"data":{"raw_url":"https://cdn.example.test/poster.jpg?sign=1"}}`))
+	}))
+	defer srv.Close()
+
+	p, err := New(TypeOpenList, map[string]any{"server": srv.URL, "token": "alist-token"}, srv.Client())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// .nfo metadata file should use API, not WebDAV
+	link, err := p.Resolve(context.Background(), "/Cloud/Movie/Movie.nfo")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if gotPath != "/api/fs/get" {
+		t.Fatalf("api path = %q, want /api/fs/get (metadata should not use WebDAV)", gotPath)
+	}
+	if gotAuth != "alist-token" {
+		t.Fatalf("Authorization = %q, want token", gotAuth)
+	}
+	if link.URL != "https://cdn.example.test/poster.jpg?sign=1" {
+		t.Fatalf("url = %q", link.URL)
+	}
+}

internal/service/cloud/pan115_openapi.go

@@ -123,35 +123,41 @@ func (p *openAPI115Provider) ResolveBatch(ctx context.Context, fileRefs []string
 // OpenClient 暴露底层客户端（token 刷新用）。
 func (p *openAPI115Provider) OpenClient() *cloud115.OpenClient { return p.c }
 
+// PutLocalFile 直接上传本地文件，避免通过 io.Reader 复制临时文件产生的磁盘开销与并发重命名碰撞。
+func (p *openAPI115Provider) PutLocalFile(ctx context.Context, parentCID, localPath string) error {
+	_, err := p.c.Upload(ctx, localPath, parentCID, "", "")
+	return err
+}
+
 // PutFileNamed 把本地元数据上传到 115 指定父目录（parentCID 为父目录 cid）。
-// io.Reader 无法携带文件名，因此走独立的 named 上传接口。将内容落为临时文件后
-// 重命名为目标文件名，再交给 115 上传（/open/upload/init 的 file_name 取真实文件名）。
+// 为防止多并发上传线程在同一临时目录下发生同名文件（如 poster.jpg）碰撞覆盖与误删，
+// 为每个上传任务分配专属临时子目录。
 func (p *openAPI115Provider) PutFileNamed(ctx context.Context, parentCID, fileName string, r io.Reader) error {
-	tmp, err := os.CreateTemp("", "mebox-upload-*")
+	tmpDir, err := os.MkdirTemp("", "mebox-upload-*")
+	if err != nil {
+		return fmt.Errorf("115: 创建临时目录失败：%w", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(tmpDir)
+	}()
+
+	safeName := filepath.Base(fileName)
+	if safeName == "" || safeName == "." {
+		safeName = "file"
+	}
+	tmpPath := filepath.Join(tmpDir, safeName)
+	dst, err := os.OpenFile(tmpPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
 	if err != nil {
 		return fmt.Errorf("115: 创建临时文件失败：%w", err)
 	}
-	tmpPath := tmp.Name()
-	defer func() {
-		_ = tmp.Close()
-		_ = os.Remove(tmpPath)
-	}()
-	if _, err := io.Copy(tmp, r); err != nil {
+	if _, err := io.Copy(dst, r); err != nil {
+		_ = dst.Close()
 		return fmt.Errorf("115: 写入临时文件失败：%w", err)
 	}
-	if err := tmp.Close(); err != nil {
+	if err := dst.Close(); err != nil {
 		return fmt.Errorf("115: 关闭临时文件失败：%w", err)
 	}
-	// 重命名为目标文件名，保证上传到 115 后保留原始文件名。
-	// 重命名失败必须 fail fast：静默用随机临时名上传会导致 115 上的文件名
-	// 变成 mebox-upload-xxx，破坏元数据文件名契约。
-	if fileName != "" && fileName != filepath.Base(tmpPath) {
-		namedPath := filepath.Join(filepath.Dir(tmpPath), fileName)
-		if err := os.Rename(tmpPath, namedPath); err != nil {
-			return fmt.Errorf("115: 重命名临时文件为 %s 失败：%w", fileName, err)
-		}
-		tmpPath = namedPath
-	}
+
 	_, err = p.c.Upload(ctx, tmpPath, parentCID, "", "")
 	if err != nil {
 		return err

internal/service/emby_remote.go

@@ -139,6 +139,37 @@ func (r *EmbyRemoteService) ListAccounts(ctx context.Context) ([]model.StrmAccou
 	return out, nil
 }
 
+// ConfiguredRemoteHosts 返回所有已配置的远程 Emby 线路的主机名/IP（去重、不含端口）。
+func (r *EmbyRemoteService) ConfiguredRemoteHosts(ctx context.Context) []string {
+	if r == nil || r.repo == nil || r.repo.StrmAccount == nil {
+		return nil
+	}
+	accounts, err := r.ListAccounts(ctx)
+	if err != nil || len(accounts) == 0 {
+		return nil
+	}
+	seen := make(map[string]bool)
+	var hosts []string
+	for _, acct := range accounts {
+		lines, _, err := r.LinesOf(&acct)
+		if err != nil {
+			continue
+		}
+		for _, line := range lines {
+			u, err := url.Parse(line.URL)
+			if err != nil || u.Hostname() == "" {
+				continue
+			}
+			h := strings.ToLower(u.Hostname())
+			if !seen[h] {
+				seen[h] = true
+				hosts = append(hosts, h)
+			}
+		}
+	}
+	return hosts
+}
+
 // AccountByID 按 ID 查找远程 Emby 挂载账号（不存在或类型不符返回 nil）。
 func (r *EmbyRemoteService) AccountByID(ctx context.Context, id string) *model.StrmAccount {
 	if strings.TrimSpace(id) == "" {

internal/service/image_proxy.go

@@ -17,6 +17,7 @@ import (
 	"net"
 	"net/http"
 	"path/filepath"
+	"strings"
 	"sync"
 	"syscall"
 	"time"
@@ -42,6 +43,13 @@ type ImageProxy struct {
 	libRootsMu     sync.Mutex
 	libRootsCache  []string
 	libRootsAt     time.Time
+
+	// allowedRemoteHostsFn returns hostnames or IPs of explicitly configured
+	// upstream services (e.g. remote Emby mounts) that should bypass SSRF private IP checks.
+	allowedRemoteHostsFn func() []string
+	allowedHostsMu       sync.Mutex
+	allowedHostsCache    map[string]bool
+	allowedHostsAt       time.Time
 }
 
 const (
@@ -51,6 +59,12 @@ const (
 
 // NewImageProxy is the constructor.
 func NewImageProxy(cfg *config.Config, log *zap.Logger) *ImageProxy {
+	proxy := &ImageProxy{
+		cfg:      cfg,
+		log:      log,
+		cacheDir: filepath.Join(cfg.Cache.CacheDir, "images"),
+	}
+
 	// Honor HTTP(S)_PROXY env vars so deployments behind GFW can pull
 	// from image.tmdb.org via their HTTP proxy without extra config. On
 	// Windows we also honor the current user's system proxy settings.
@@ -63,6 +77,7 @@ func NewImageProxy(cfg *config.Config, log *zap.Logger) *ImageProxy {
 		// 仅 URL 解析层的 isPrivateHost 可被十进制/十六进制 IP、解析到
 		// 私网的域名与 DNS rebinding 绕过；在拨号层对最终连接 IP 做二次
 		// 校验（含重定向后的每条连接）堵住该旁路。
+		// 用户明确配置的远程挂载源（如内网 Emby）豁免该私网限制。
 		dialer := &net.Dialer{
 			Timeout: 15 * time.Second,
 			Control: func(_, address string, _ syscall.RawConn) error {
@@ -70,6 +85,9 @@ func NewImageProxy(cfg *config.Config, log *zap.Logger) *ImageProxy {
 				if err != nil {
 					return err
 				}
+				if proxy.isAllowedRemoteHost(host) {
+					return nil
+				}
 				ip := net.ParseIP(host)
 				if ip == nil {
 					return errors.New("image proxy: refusing non-IP dial target")
@@ -82,12 +100,9 @@ func NewImageProxy(cfg *config.Config, log *zap.Logger) *ImageProxy {
 		}
 		transport.DialContext = dialer.DialContext
 	}
-	return &ImageProxy{
-		cfg:      cfg,
-		log:      log,
-		cacheDir: filepath.Join(cfg.Cache.CacheDir, "images"),
-		client:   &http.Client{Timeout: 30 * time.Second, Transport: transport},
-	}
+
+	proxy.client = &http.Client{Timeout: 30 * time.Second, Transport: transport}
+	return proxy
 }
 
 // proxyConfiguredForImageFetch 探测环境变量或系统代理是否会影响图片抓取。
@@ -125,6 +140,47 @@ func (p *ImageProxy) libraryRoots() []string {
 	return p.libRootsCache
 }
 
+// SetAllowedRemoteHostsProvider injects a callback that returns hostnames or IPs
+// of explicitly configured remote services (e.g. remote Emby mounts). Requests to
+// these hosts bypass SSRF private-IP restrictions.
+func (p *ImageProxy) SetAllowedRemoteHostsProvider(fn func() []string) {
+	p.allowedRemoteHostsFn = fn
+}
+
+func (p *ImageProxy) isAllowedRemoteHost(host string) bool {
+	if p == nil || p.allowedRemoteHostsFn == nil {
+		return false
+	}
+	host = strings.ToLower(strings.TrimSpace(host))
+	if host == "" {
+		return false
+	}
+	// Strip port if present
+	if h, _, err := net.SplitHostPort(host); err == nil {
+		host = strings.ToLower(strings.TrimSpace(h))
+	}
+
+	p.allowedHostsMu.Lock()
+	defer p.allowedHostsMu.Unlock()
+	if p.allowedHostsCache == nil || time.Since(p.allowedHostsAt) >= 30*time.Second {
+		rawList := p.allowedRemoteHostsFn()
+		cache := make(map[string]bool, len(rawList))
+		for _, item := range rawList {
+			item = strings.ToLower(strings.TrimSpace(item))
+			if item == "" {
+				continue
+			}
+			if h, _, err := net.SplitHostPort(item); err == nil {
+				item = strings.ToLower(strings.TrimSpace(h))
+			}
+			cache[item] = true
+		}
+		p.allowedHostsCache = cache
+		p.allowedHostsAt = time.Now()
+	}
+	return p.allowedHostsCache[host]
+}
+
 // Prune removes oldest cached images until disk usage is within the configured limit.
 func (p *ImageProxy) Prune() (PruneImageCacheResult, error) {
 	if p.cfg == nil || p.cfg.Cache.ImagesMaxSizeMB <= 0 {

internal/service/image_proxy_paths.go

@@ -22,7 +22,7 @@ func (p *ImageProxy) validateURL(raw string) (*url.URL, error) {
 	if scheme != "http" && scheme != "https" {
 		return nil, errors.New("unsupported scheme")
 	}
-	if isPrivateHost(u.Hostname()) {
+	if !p.isAllowedRemoteHost(u.Hostname()) && isPrivateHost(u.Hostname()) {
 		return nil, errors.New("requests to private/internal hosts are not allowed")
 	}
 	return u, nil

internal/service/image_proxy_remote_fetch.go

@@ -51,7 +51,7 @@ func (p *ImageProxy) fetchRemoteImageOnce(ctx context.Context, raw, host string,
 		p.log.Warn("imageproxy: build request failed", zap.String("url", raw), zap.Error(err))
 		return nil, "", "", errImageProxyRequestSetup
 	}
-	applyRemoteImageHeaders(req, host)
+	applyRemoteImageHeaders(req, host, raw)
 
 	resp, err := candidate.client.Do(req)
 	if err != nil {
@@ -79,7 +79,7 @@ func (p *ImageProxy) fetchRemoteImageOnce(ctx context.Context, raw, host string,
 	return data, ctype, resp.Header.Get("Content-Length"), nil
 }
 
-func applyRemoteImageHeaders(req *http.Request, host string) {
+func applyRemoteImageHeaders(req *http.Request, host, raw string) {
 	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0 Safari/537.36")
 	req.Header.Set("Accept", "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8")
 	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,ja;q=0.8,en;q=0.7")
@@ -88,7 +88,7 @@ func applyRemoteImageHeaders(req *http.Request, host string) {
 	if cookie := remoteImageCookie(host); cookie != "" {
 		req.Header.Set("Cookie", cookie)
 	}
-	if referer := remoteImageReferer(host); referer != "" {
+	if referer := remoteImageReferer(host, raw); referer != "" {
 		req.Header.Set("Referer", referer)
 	}
 }
@@ -105,7 +105,7 @@ func remoteImageCookie(host string) string {
 	}
 }
 
-func remoteImageReferer(host string) string {
+func remoteImageReferer(host, raw string) string {
 	h := strings.ToLower(strings.TrimSpace(host))
 	switch {
 	case strings.Contains(h, "doubanio.com"):
@@ -125,7 +125,11 @@ func remoteImageReferer(host string) string {
 	case strings.Contains(h, "fc2.com"):
 		return "https://adult.contents.fc2.com/"
 	case h != "":
-		return "https://" + h + "/"
+		scheme := "https"
+		if strings.HasPrefix(strings.ToLower(strings.TrimSpace(raw)), "http://") {
+			scheme = "http"
+		}
+		return scheme + "://" + h + "/"
 	default:
 		return ""
 	}
@@ -158,9 +162,9 @@ func fetchRemoteImageWithCurl(ctx context.Context, raw, host string) ([]byte, st
 		"--header", "Cache-Control: no-cache",
 		"--header", "Pragma: no-cache",
 	}
-	if referer := remoteImageReferer(host); referer != "" {
-		args = append(args, "--referer", referer)
-	}
+		if referer := remoteImageReferer(host, raw); referer != "" {
+			args = append(args, "--referer", referer)
+		}
 	if cookie := remoteImageCookie(host); cookie != "" {
 		args = append(args, "--cookie", cookie)
 	}

internal/service/image_proxy_remote_test.go

@@ -317,9 +317,14 @@ func TestRemoteImageRefererForAdultHosts(t *testing.T) {
 		{"example.com", "https://example.com/"},
 		{"", ""},
 	}
-	for _, tt := range tests {
-		if got := remoteImageReferer(tt.host); got != tt.want {
-			t.Errorf("remoteImageReferer(%q) = %q, want %q", tt.host, got, tt.want)
+		for _, tt := range tests {
+			if got := remoteImageReferer(tt.host, "https://"+tt.host+"/img.jpg"); got != tt.want {
+				t.Errorf("remoteImageReferer(%q) = %q, want %q", tt.host, got, tt.want)
+			}
+		}
+
+		// Also verify HTTP protocol preservation for generic hosts
+		if got := remoteImageReferer("192.168.1.100", "http://192.168.1.100:8096/image"); got != "http://192.168.1.100/" {
+			t.Errorf("remoteImageReferer for HTTP host = %q, want http://192.168.1.100/", got)
 		}
 	}
-}

internal/service/image_proxy_test.go

@@ -117,9 +117,32 @@ func TestIsPrivateHost(t *testing.T) {
 	// Hostnames must NOT be blocked even though GFW DNS poisoning may resolve
 	// them to private/loopback IPs — blocking them broke legitimate posters.
 	allowed := []string{"image.tmdb.org", "lain.bgm.tv", "example.com", "8.8.8.8"}
-	for _, h := range allowed {
-		if isPrivateHost(h) {
-			t.Errorf("isPrivateHost(%q) = true, want false", h)
+		for _, h := range allowed {
+			if isPrivateHost(h) {
+				t.Errorf("isPrivateHost(%q) = true, want false", h)
+			}
 		}
 	}
+
+func TestImageProxyAllowedRemoteHostBypassesPrivateCheck(t *testing.T) {
+	proxy := NewImageProxy(&config.Config{Cache: config.CacheConfig{CacheDir: filepath.Join(t.TempDir(), "cache")}}, zap.NewNop())
+
+	rawURL := "http://192.168.1.100:8096/emby/Items/123/Images/Primary"
+	// Before setting allowed remote hosts, private host is rejected by validateURL
+	if _, err := proxy.validateURL(rawURL); err == nil {
+		t.Fatal("expected validateURL to reject private IP before whitelist")
+	}
+
+	// After configuring whitelist with the Emby host
+	proxy.SetAllowedRemoteHostsProvider(func() []string {
+		return []string{"192.168.1.100:8096"}
+	})
+
+	u, err := proxy.validateURL(rawURL)
+	if err != nil {
+		t.Fatalf("expected validateURL to allow whitelisted host, got: %v", err)
+	}
+	if u.Hostname() != "192.168.1.100" {
+		t.Fatalf("hostname = %s, want 192.168.1.100", u.Hostname())
+	}
 }

internal/service/service_builder.go

@@ -177,6 +177,11 @@ func (b *serviceContainerBuilder) initIdentityServices() {
 func (b *serviceContainerBuilder) initImageProxy() {
 	b.c.ImageProxy = NewImageProxy(b.cfg, b.log)
 	b.c.ImageProxy.SetLibraryRootsProvider(b.libraryRoots)
+	if b.c.EmbyRemote != nil {
+		b.c.ImageProxy.SetAllowedRemoteHostsProvider(func() []string {
+			return b.c.EmbyRemote.ConfiguredRemoteHosts(context.Background())
+		})
+	}
 	b.c.Scan.SetImageProxy(b.c.ImageProxy)
 	b.c.Scraper.SetImageProxy(b.c.ImageProxy)
 }

internal/service/strm_queue.go

@@ -366,9 +366,11 @@ func (s *StrmService) processUpload115(ctx context.Context, task *model.StrmUplo
 		finish(model.StrmTaskFailed, "该网盘不支持元数据上传")
 		return
 	}
-	// 以本地为准：网盘端已有同名但内容不同的旧元数据时，先批量删除所有旧副本再上传。
-	// 115 的上传接口不保证同名覆盖，直接上传可能产生同名重复文件；删除失败则
-	// 任务重试（旧文件 ID 失效的场景会在下次同步后自动修复）。
+	// 以本地为准：网盘端已有同名但内容不同的旧元数据时，先尝试批量删除所有旧副本再上传。
+	// 115 的上传接口不保证同名覆盖，直接上传可能产生同名重复文件。
+	// 删除失败时不中止任务——继续上传新文件，旧副本交由下次同步的 cleanupBatchRedundantFiles
+	// 按目录批量清理（下次同步会看到新旧两个版本，命中新版本后把旧版本 cid 收入 pendingDeletes
+	// 异步删除）。这样避免了「删旧失败 → 任务重试 → 再次删旧失败 → 永远无法上传」的死循环。
 	if task.RemoteRef != "" {
 		open115, ok := provider.(cloud.OpenAPI115Provider)
 		if !ok {
@@ -376,24 +378,39 @@ func (s *StrmService) processUpload115(ctx context.Context, task *model.StrmUplo
 			return
 		}
 		refs := strings.Split(task.RemoteRef, ",")
-		if err := open115.OpenClient().DeleteFiles(ctx, task.RemotePath, refs...); err != nil {
-			s.uploadTaskFailWithRetry(task, "删除网盘旧元数据失败："+err.Error())
+			if err := open115.OpenClient().DeleteFiles(ctx, task.RemotePath, refs...); err != nil {
+				s.log.Warn("删除网盘旧元数据失败，跳过删除继续上传新文件",
+					zap.String("task_id", task.ID),
+					zap.String("local_path", task.LocalPath),
+					zap.Error(err))
+				// 不 return：继续上传新文件，旧副本由下次同步清理
+			}
+		}
+		// 优先使用直接本地文件上传接口，零拷贝且彻底根除并发临时文件同名碰撞
+		if localUploader, ok := provider.(interface {
+			PutLocalFile(ctx context.Context, parentCID, localPath string) error
+		}); ok {
+			if err := localUploader.PutLocalFile(ctx, task.RemotePath, task.LocalPath); err != nil {
+				s.uploadTaskFailWithRetry(task, "上传失败："+err.Error())
+				return
+			}
+			finish(model.StrmTaskDone, "")
+			return
+		}
+
+		f, err := os.Open(task.LocalPath)
+		if err != nil {
+			s.uploadTaskFailWithRetry(task, "打开本地文件失败："+err.Error())
+			return
+		}
+		if err := named.PutFileNamed(ctx, task.RemotePath, task.FileName, f); err != nil {
+			_ = f.Close()
+			s.uploadTaskFailWithRetry(task, "上传失败："+err.Error())
 			return
 		}
-	}
-	f, err := os.Open(task.LocalPath)
-	if err != nil {
-		s.uploadTaskFailWithRetry(task, "打开本地文件失败："+err.Error())
-		return
-	}
-	if err := named.PutFileNamed(ctx, task.RemotePath, task.FileName, f); err != nil {
 		_ = f.Close()
-		s.uploadTaskFailWithRetry(task, "上传失败："+err.Error())
-		return
+		finish(model.StrmTaskDone, "")
 	}
-	_ = f.Close()
-	finish(model.StrmTaskDone, "")
-}
 
 // downloadTaskFailWithRetry 下载失败任务按退避重试，超过上限标记 failed。
 func (s *StrmService) downloadTaskFailWithRetry(task *model.StrmDownloadTask, message string) {

internal/service/strm_sync.go

@@ -25,6 +25,8 @@ import (
 	"github.com/truewhile/MeBox/internal/service/cloud115"
 )
 
+var errFallbackToWalkRemote = errors.New("fallback to walk remote")
+
 // remoteMetaItem 记录远端存在的单个元数据文件副本信息（大小、文件ID、内容SHA1、修改时间）。
 type remoteMetaItem struct {
 	ID    string
@@ -352,8 +354,17 @@ func (st *strmSyncState) run() error {
 
 	if st.provider != nil {
 		if open115, ok := st.provider.(cloud.OpenAPI115Provider); ok && st.p.Provider == model.StrmProvider115 {
-			if err := st.walk115Flat(open115.OpenClient()); err != nil {
-				return err
+			err := st.walk115Flat(open115.OpenClient())
+			if err != nil {
+				if errors.Is(err, errFallbackToWalkRemote) {
+					st.s.log.Warn("115: 扁平列表文件数超限，自动降级为传统并发递归同步",
+						zap.String("path_id", st.p.ID))
+					if errWalk := st.walkRemote(); errWalk != nil {
+						return errWalk
+					}
+				} else {
+					return err
+				}
 			}
 		} else {
 			if err := st.walkRemote(); err != nil {
@@ -503,28 +514,31 @@ func (st *strmSyncState) walkRemote() error {
 						if task.rel != "" {
 							rel = task.rel + "/" + cleanName
 						}
-						if entry.IsDir {
-							push(dirTask{id: entry.ID, rel: rel})
-						} else {
-							st.processRemoteFile(entry, rel)
+							if entry.IsDir {
+								st.dirCache.Store(entry.ID, rel)
+								st.deferDirCacheSave(entry.ID, rel)
+								push(dirTask{id: entry.ID, rel: rel})
+							} else {
+								st.processRemoteFile(entry, rel)
+							}
 						}
+						walkMu.Lock()
+						pending--
+						if pending == 0 {
+							walkCond.Broadcast()
+						}
+						walkMu.Unlock()
 					}
-					walkMu.Lock()
-					pending--
-					if pending == 0 {
-						walkCond.Broadcast()
-					}
-					walkMu.Unlock()
+				}); err != nil {
+					cancel()
 				}
-			}); err != nil {
-				cancel()
-			}
-		}()
-	}
-	wg.Wait()
-	if firstErr != nil {
-		return firstErr
-	}
+			}()
+		}
+		wg.Wait()
+		st.flushDirCacheSave()
+		if firstErr != nil {
+			return firstErr
+		}
 	return ctx.Err()
 }
 
@@ -663,86 +677,16 @@ func (st *strmSyncState) walk115Flat(open115 *cloud115.OpenClient) error {
 				if pathCounts[item.Path] > 1 {
 					continue
 				}
-				st.dirCache.Store(item.DirID, cleanDirRel(item.Path))
+					st.dirCache.Store(item.DirID, cleanDirRel(item.Path))
+				}
 			}
 		}
-	}
 
-	// 2. 探测文件总数
-	const pageSize = 1150
-	firstBatch, totalCount, err := open115.GetFsListFlat(ctx, rootCID, 0, pageSize)
-	if err != nil {
-		return fmt.Errorf("115: 获取文件列表失败：%w", err)
-	}
-
-	st.updateSyncMessage(fmt.Sprintf("正在拉取远端文件列表 (共 %d 个文件)...", totalCount))
-
-	allFiles := make([]cloud115.RemoteFile, 0, totalCount)
-	allFiles = append(allFiles, firstBatch...)
-
-	// 3. 并发分页拉取剩余文件
-	if totalCount > int64(len(firstBatch)) {
-		totalPages := int((totalCount + pageSize - 1) / pageSize)
-		type pageTask struct {
-			offset int
+		// 2. 自适应分治拉取文件列表（单目录超 9500 时自动对子目录并发分治扁平化）
+		allFiles, err := st.fetch115FilesAdaptive(ctx, open115, rootCID)
+		if err != nil {
+			return err
 		}
-		pageTasks := make([]pageTask, 0, totalPages-1)
-		for page := 1; page < totalPages; page++ {
-			pageTasks = append(pageTasks, pageTask{offset: page * pageSize})
-		}
-
-		var (
-			filesMu  sync.Mutex
-			wg       sync.WaitGroup
-			taskCh   = make(chan pageTask, len(pageTasks))
-			errMu    sync.Mutex
-			fetchErr error
-		)
-
-		for _, t := range pageTasks {
-			taskCh <- t
-		}
-		close(taskCh)
-
-		workers := 8
-		if len(pageTasks) < workers {
-			workers = len(pageTasks)
-		}
-
-		for i := 0; i < workers; i++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				// 分页拉取 panic 时取消整个同步；正常退出不取消。
-				if err := helper.Recover(st.s.log, "strm.sync.walk115.page", func() error {
-					for t := range taskCh {
-						if ctx.Err() != nil {
-							return nil
-						}
-						files, _, err := open115.GetFsListFlat(ctx, rootCID, t.offset, pageSize)
-						if err != nil {
-							errMu.Lock()
-							if fetchErr == nil {
-								fetchErr = err
-							}
-							errMu.Unlock()
-							return nil
-						}
-						filesMu.Lock()
-						allFiles = append(allFiles, files...)
-						filesMu.Unlock()
-					}
-					return nil
-				}); err != nil {
-					cancel()
-				}
-			}()
-		}
-		wg.Wait()
-		if fetchErr != nil {
-			return fmt.Errorf("115: 分页拉取失败：%w", fetchErr)
-		}
-	}
 
 	if ctx.Err() != nil {
 		return ctx.Err()
@@ -958,6 +902,289 @@ feed:
 	return ctx.Err()
 }
 
+const (
+	flat115PageSize     = 1150
+	flat115Threshold    = 9500
+	max115AdaptiveDepth = 10
+)
+
+type adaptive115Task struct {
+	cid   string
+	rel   string
+	depth int
+}
+
+// fetch115FlatSubtree 扁平拉取单个文件数在安全阈值内的子树全部文件。
+func fetch115FlatSubtree(ctx context.Context, open115 *cloud115.OpenClient, cid string, firstBatch []cloud115.RemoteFile, totalCount int64, log *zap.Logger) ([]cloud115.RemoteFile, error) {
+	allFiles := make([]cloud115.RemoteFile, 0, totalCount)
+	allFiles = append(allFiles, firstBatch...)
+	if totalCount <= int64(len(firstBatch)) {
+		return allFiles, nil
+	}
+
+	totalPages := int((totalCount + flat115PageSize - 1) / flat115PageSize)
+	type pageTask struct {
+		offset int
+	}
+	pageTasks := make([]pageTask, 0, totalPages-1)
+	for page := 1; page < totalPages; page++ {
+		pageTasks = append(pageTasks, pageTask{offset: page * flat115PageSize})
+	}
+
+	var (
+		filesMu  sync.Mutex
+		wg       sync.WaitGroup
+		taskCh   = make(chan pageTask, len(pageTasks))
+		errMu    sync.Mutex
+		fetchErr error
+	)
+	for _, t := range pageTasks {
+		taskCh <- t
+	}
+	close(taskCh)
+
+	workers := 8
+	if len(pageTasks) < workers {
+		workers = len(pageTasks)
+	}
+
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := helper.Recover(log, "strm.sync.walk115.page", func() error {
+				for t := range taskCh {
+					if ctx.Err() != nil {
+						return nil
+					}
+					files, _, err := open115.GetFsListFlat(ctx, cid, t.offset, flat115PageSize)
+					if err != nil {
+						errMu.Lock()
+						if fetchErr == nil {
+							fetchErr = err
+						}
+						errMu.Unlock()
+						return nil
+					}
+					filesMu.Lock()
+					allFiles = append(allFiles, files...)
+					filesMu.Unlock()
+				}
+				return nil
+			}); err != nil {
+				errMu.Lock()
+				if fetchErr == nil {
+					fetchErr = err
+				}
+				errMu.Unlock()
+			}
+		}()
+	}
+	wg.Wait()
+	if fetchErr != nil {
+		return nil, fmt.Errorf("115: 分页拉取失败：%w", fetchErr)
+	}
+	return allFiles, nil
+}
+
+// list115DirDirect 列出指定目录下的直接子项（单层 cur=1&show_dir=1）。
+func list115DirDirect(ctx context.Context, open115 *cloud115.OpenClient, cid string) ([]cloud115.RemoteFile, error) {
+	var out []cloud115.RemoteFile
+	for offset := 0; ; offset += flat115PageSize {
+		files, _, err := open115.GetFsList(ctx, cid, offset, flat115PageSize)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, files...)
+		if len(files) < flat115PageSize {
+			break
+		}
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+	}
+	return out, nil
+}
+
+// fetch115FilesAdaptive 采用自适应分治策略抓取 115 目录树下的全部文件：
+// 115 开放平台扁平搜索对 offset+limit 有 10000 的最大深度限制。
+// - 若子树文件总数 < 9500，直接使用全速扁平分页批量拉取；
+// - 若子树文件总数 >= 9500（大库或超大分类目录），自动分治：仅单层列出该目录的直属子项（cur=1），
+//   直属纯文件直接收集，直属子目录则派发为独立的子树任务继续递归探测与拉取；
+// - 若超大单目录下无子目录或层级过深（>10层），安全回退到 errFallbackToWalkRemote。
+func (st *strmSyncState) fetch115FilesAdaptive(ctx context.Context, open115 *cloud115.OpenClient, rootCID string) ([]cloud115.RemoteFile, error) {
+	var (
+		allFiles []cloud115.RemoteFile
+		filesMu  sync.Mutex
+
+		walkMu   sync.Mutex
+		walkCond = sync.NewCond(&walkMu)
+		work     []adaptive115Task
+		pending  int
+
+		errMu    sync.Mutex
+		firstErr error
+	)
+
+	push := func(t adaptive115Task) {
+		walkMu.Lock()
+		work = append(work, t)
+		pending++
+		walkCond.Signal()
+		walkMu.Unlock()
+	}
+
+	go func() {
+		<-ctx.Done()
+		walkMu.Lock()
+		walkCond.Broadcast()
+		walkMu.Unlock()
+	}()
+
+	push(adaptive115Task{cid: rootCID, rel: "", depth: 0})
+
+	workers := 8
+	var wg sync.WaitGroup
+
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := helper.Recover(st.s.log, "strm.sync.walk115.adaptive", func() error {
+				for {
+					walkMu.Lock()
+					for len(work) == 0 {
+						if ctx.Err() != nil || pending == 0 {
+							walkMu.Unlock()
+							return nil
+						}
+						walkCond.Wait()
+					}
+					task := work[0]
+					work = work[1:]
+					walkMu.Unlock()
+
+					if ctx.Err() != nil {
+						walkMu.Lock()
+						pending--
+						walkCond.Broadcast()
+						walkMu.Unlock()
+						return nil
+					}
+
+					firstBatch, totalCount, err := open115.GetFsListFlat(ctx, task.cid, 0, flat115PageSize)
+					if err != nil {
+						errMu.Lock()
+						if firstErr == nil {
+							firstErr = fmt.Errorf("115: 获取文件列表失败（cid=%s）：%w", task.cid, err)
+						}
+						errMu.Unlock()
+						walkMu.Lock()
+						pending--
+						walkCond.Broadcast()
+						walkMu.Unlock()
+						return nil
+					}
+
+					if totalCount < flat115Threshold {
+						// 安全深度内：直接扁平拉取该子树全部文件
+						files, err := fetch115FlatSubtree(ctx, open115, task.cid, firstBatch, totalCount, st.s.log)
+						if err != nil {
+							errMu.Lock()
+							if firstErr == nil {
+								firstErr = err
+							}
+							errMu.Unlock()
+							walkMu.Lock()
+							pending--
+							walkCond.Broadcast()
+							walkMu.Unlock()
+							return nil
+						}
+						filesMu.Lock()
+						allFiles = append(allFiles, files...)
+						currentCount := len(allFiles)
+						filesMu.Unlock()
+						st.updateSyncMessage(fmt.Sprintf("正在拉取远端文件列表 (已获取 %d 个文件)...", currentCount))
+					} else {
+						// 子树过大（>=9500）：分治展开该目录直接子项
+						if task.depth >= max115AdaptiveDepth {
+							// 深度超限兜底：单目录嵌套超 10 层仍超 9500，回退为传统递归
+							errMu.Lock()
+							if firstErr == nil {
+								firstErr = errFallbackToWalkRemote
+							}
+							errMu.Unlock()
+							walkMu.Lock()
+							pending--
+							walkCond.Broadcast()
+							walkMu.Unlock()
+							return nil
+						}
+						st.s.log.Info("115: 目录文件数超限，自动分治展开子目录并发扁平拉取",
+							zap.String("cid", task.cid),
+							zap.String("rel", task.rel),
+							zap.Int64("total_count", totalCount),
+							zap.Int("depth", task.depth))
+
+						directEntries, err := list115DirDirect(ctx, open115, task.cid)
+						if err != nil {
+							errMu.Lock()
+							if firstErr == nil {
+								firstErr = fmt.Errorf("115: 列出单层目录失败（cid=%s）：%w", task.cid, err)
+							}
+							errMu.Unlock()
+							walkMu.Lock()
+							pending--
+							walkCond.Broadcast()
+							walkMu.Unlock()
+							return nil
+						}
+
+						for _, f := range directEntries {
+							if f.Category == cloud115.TypeDir {
+								cleanName := cleanEntryName(f.FileName, true)
+								subRel := cleanName
+								if task.rel != "" {
+									subRel = task.rel + "/" + cleanName
+								}
+								st.dirCache.Store(f.FileId, subRel)
+								st.deferDirCacheSave(f.FileId, subRel)
+								push(adaptive115Task{cid: f.FileId, rel: subRel, depth: task.depth + 1})
+							} else {
+								filesMu.Lock()
+								allFiles = append(allFiles, f)
+								filesMu.Unlock()
+							}
+						}
+					}
+
+					walkMu.Lock()
+					pending--
+					if pending == 0 {
+						walkCond.Broadcast()
+					}
+					walkMu.Unlock()
+				}
+			}); err != nil {
+				errMu.Lock()
+				if firstErr == nil {
+					firstErr = err
+				}
+				errMu.Unlock()
+			}
+		}()
+	}
+
+	wg.Wait()
+	if firstErr != nil {
+		return nil, firstErr
+	}
+	return allFiles, nil
+}
+
 // handleVideo 生成/更新 .strm 文件。
 func (st *strmSyncState) handleVideo(entry cloud.FileEntry, rel, ext string) {
 	relSansExt := rel[:len(rel)-len(ext)]
@@ -1114,6 +1341,7 @@ func (st *strmSyncState) localSha1Matches(path, remoteSha1 string) bool {
 }
 
 // recordRemoteMeta 记录远端存在的元数据索引、文件大小、文件引用及内容 SHA1（多副本聚合追加）。
+// 对同一文件 ID 严格去重，避免当 download_meta 与 upload_meta 同时开启时因重复记录引发误判与自杀式删除。
 func (st *strmSyncState) recordRemoteMeta(entry cloud.FileEntry, rel string) {
 	st.mu.Lock()
 	defer st.mu.Unlock()
@@ -1122,6 +1350,13 @@ func (st *strmSyncState) recordRemoteMeta(entry cloud.FileEntry, rel string) {
 	}
 	key := "m:" + rel
 	st.seenMeta[key] = true
+	if entry.ID != "" {
+		for _, existing := range st.remoteMeta[key] {
+			if existing.ID == entry.ID {
+				return
+			}
+		}
+	}
 	st.remoteMeta[key] = append(st.remoteMeta[key], remoteMetaItem{
 		ID:    entry.ID,
 		Size:  entry.Size,
@@ -1397,21 +1632,23 @@ func (st *strmSyncState) scanLocalMetaForUpload() error {
 					}
 				}
 			}
-			if matchedIdx >= 0 {
-				// 远端已存在完全一致的副本，跳过上传！
-				// 若远端还存在其他同名脏副本（副本总数 > 1），在 115 下收集待删除 ID，稍后按目录批量删除
-				if len(entries) > 1 && st.p.Provider == model.StrmProvider115 {
-					parentCID := st.uploadRemoteTarget(rel)
-					if parentCID != "" {
-						for i, it := range entries {
-							if i != matchedIdx && it.ID != "" {
-								pendingDeletes[parentCID] = append(pendingDeletes[parentCID], it.ID)
+				if matchedIdx >= 0 {
+					// 远端已存在完全一致的副本，跳过上传！
+					// 若远端还存在其他同名脏副本（副本总数 > 1），在 115 下收集待删除 ID，稍后按目录批量删除。
+					// 严禁将已命中的最新副本 ID (matchedID) 放入待删列表，杜绝误杀唯一有效副本。
+					if len(entries) > 1 && st.p.Provider == model.StrmProvider115 {
+						parentCID := st.uploadRemoteTarget(rel)
+						if parentCID != "" {
+							matchedID := entries[matchedIdx].ID
+							for i, it := range entries {
+								if i != matchedIdx && it.ID != "" && it.ID != matchedID {
+									pendingDeletes[parentCID] = append(pendingDeletes[parentCID], it.ID)
+								}
 							}
 						}
 					}
+					return nil
 				}
-				return nil
-			}
 		}
 
 		remoteTarget := st.uploadRemoteTarget(rel)

internal/service/strm_sync_test.go

@@ -1319,3 +1319,137 @@ func TestScanLocalMetaForUploadMultipleCopiesAllStale(t *testing.T) {
 		t.Fatalf("expected RemoteRef to be 'old-1,old-2', got %q", tasks[0].RemoteRef)
 	}
 }
+
+// TestRecordRemoteMetaDeduplication 验证当 download_meta 与 upload_meta 同时开启时，
+// 同一远端元数据被多次入账不会在 remoteMeta 中生成重复副本，杜绝误判自杀式删除。
+func TestRecordRemoteMetaDeduplication(t *testing.T) {
+	st := &strmSyncState{
+		seenMeta:   map[string]bool{},
+		remoteMeta: map[string][]remoteMetaItem{},
+	}
+	entry := cloud.FileEntry{
+		ID:    "unique-fid-1",
+		Name:  "test.nfo",
+		Size:  100,
+		Sha1:  "AAAABBBBCCCC",
+		MTime: 12345,
+	}
+	// 连续记录两次同一文件
+	st.recordRemoteMeta(entry, "dir/test.nfo")
+	st.recordRemoteMeta(entry, "dir/test.nfo")
+
+	items := st.remoteMeta["m:dir/test.nfo"]
+	if len(items) != 1 {
+		t.Fatalf("expected 1 item after duplicate record, got %d", len(items))
+	}
+}
+
+// TestWalk115AdaptiveHierarchicalFlatScan 验证自适应分治扁平化扫描：
+// 当根目录探测总数 >= 9500 时，系统自动分治展开单层直接子项，对各子目录分别执行扁平拉取，
+// 正确合并根目录直属文件与各子目录深层文件，突破 115 开放平台 10000 深度限制。
+func TestWalk115AdaptiveHierarchicalFlatScan(t *testing.T) {
+	svc := testStrmService(t)
+	localDir := t.TempDir()
+	acct := &model.StrmAccount{Name: "fake115-adaptive", Provider: "cloud115", Config: "{}", Enabled: true}
+	if err := svc.repo.StrmAccount.Create(context.Background(), acct); err != nil {
+		t.Fatal(err)
+	}
+	p := &model.StrmSyncPath{
+		Base:       model.Base{ID: "adaptive-path"},
+		AccountID:  acct.ID,
+		Provider:   model.StrmProvider115,
+		RemotePath: "0",
+		LocalPath:  localDir,
+	}
+
+	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		q := r.URL.Query()
+		cid := q.Get("cid")
+		cur := q.Get("cur")
+
+		switch r.URL.Path {
+		case "/open/ufile/files":
+			if cid == "0" && cur == "0" {
+				// 根目录扁平探测：模拟总文件数 12000 超限 (>= 9500)
+				w.Write([]byte(`{"state":true,"count":12000,"data":[]}`))
+				return
+			}
+			if cid == "0" && cur == "1" {
+				// 根目录单层列举：返回 1 个直属视频和 2 个子目录
+				w.Write([]byte(`{"state":true,"count":3,"data":[
+					{"fid":"100","pid":"0","fc":"1","fn":"root.mkv","pc":"pcr","upt":1700000000,"fs":1024},
+					{"fid":"1001","pid":"0","fc":"0","fn":"Heyzo","upt":1700000001,"fs":0},
+					{"fid":"1002","pid":"0","fc":"0","fn":"S1","upt":1700000002,"fs":0}]}`))
+				return
+			}
+			if cid == "1001" {
+				// 子目录 Heyzo 扁平拉取：文件数安全 (< 9500)
+				w.Write([]byte(`{"state":true,"count":2,"data":[
+					{"fid":"201","pid":"1001","fc":"1","fn":"h1.mkv","pc":"pc201","upt":1700000001,"fs":1024},
+					{"fid":"202","pid":"1001","fc":"1","fn":"h2.mkv","pc":"pc202","upt":1700000002,"fs":2048}]}`))
+				return
+			}
+			if cid == "1002" {
+				// 子目录 S1 扁平拉取：文件数安全 (< 9500)
+				w.Write([]byte(`{"state":true,"count":1,"data":[
+					{"fid":"301","pid":"1002","fc":"1","fn":"s1.mkv","pc":"pc301","upt":1700000003,"fs":4096}]}`))
+				return
+			}
+			t.Errorf("unexpected files query: %s", r.URL.RawQuery)
+		case "/open/folder/get_info":
+			fileID := q.Get("file_id")
+			switch fileID {
+			case "1001":
+				w.Write([]byte(`{"state":true,"data":{"file_id":"1001","file_name":"Heyzo","file_category":"0",
+					"paths":[{"file_id":"0","file_name":"根目录"},{"file_id":"1001","file_name":"Heyzo"}]}}`))
+			case "1002":
+				w.Write([]byte(`{"state":true,"data":{"file_id":"1002","file_name":"S1","file_category":"0",
+					"paths":[{"file_id":"0","file_name":"根目录"},{"file_id":"1002","file_name":"S1"}]}}`))
+			default:
+				t.Errorf("unexpected get_info file_id: %s", fileID)
+			}
+		default:
+			t.Errorf("unexpected path %s", r.URL.Path)
+		}
+	}))
+	defer api.Close()
+	oldPro := cloud115.ProAPIBase
+	cloud115.ProAPIBase = api.URL
+	defer func() { cloud115.ProAPIBase = oldPro }()
+
+	oc := cloud115.NewOpenClient("app", "at", "rt")
+	st := &strmSyncState{
+		s:               svc,
+		ctx:             context.Background(),
+		p:               p,
+		provider:        cloud.NewOpenAPI115("app", "at", "rt"),
+		cfg:             &strmPathConfig{VideoExt: []string{"mkv"}, MetaExt: []string{"nfo"}, AddPath: 1},
+		rec:             &model.StrmSyncRecord{},
+		syncType:        model.StrmSyncTypeFull,
+		dirCache:        sync.Map{},
+		seenVideo:       map[string]bool{},
+		seenMeta:        map[string]bool{},
+		remoteMeta:      map[string][]remoteMetaItem{},
+		seenMetaTarget:  map[string]cloud.FileEntry{},
+		seenVideoTarget: map[string]cloud.FileEntry{},
+	}
+	if err := st.walk115Flat(oc); err != nil {
+		t.Fatalf("walk115Flat adaptive failed: %v", err)
+	}
+
+	// 1个根目录视频 + 2个Heyzo视频 + 1个S1视频 = 共4个视频成功生成 .strm
+	if st.rec.NewStrm != 4 {
+		t.Fatalf("expected 4 strm created, got %d", st.rec.NewStrm)
+	}
+	expectedFiles := []string{
+		filepath.Join(localDir, "root.strm"),
+		filepath.Join(localDir, "Heyzo", "h1.strm"),
+		filepath.Join(localDir, "Heyzo", "h2.strm"),
+		filepath.Join(localDir, "S1", "s1.strm"),
+	}
+	for _, f := range expectedFiles {
+		if _, err := os.Stat(f); err != nil {
+			t.Fatalf("expected strm %s to exist, err: %v", f, err)
+		}
+	}
+}

web/src/pages/AdminLibraryTable.tsx

@@ -2,6 +2,7 @@ import { useEffect, useRef, useState, type DragEvent, type MouseEvent, type Reac
 import { createPortal } from 'react-dom'
 import { Folder, GripVertical, Image, MoreVertical, Plus, Power, PowerOff, RefreshCw, Save, Trash2 } from 'lucide-react'
 
+import { imageURL } from '../api/client'
 import { LocalDirBrowserDialog } from '../components/LocalDirBrowserDialog'
 import type { Library, LibraryRoot } from '../types'
 import type { RootDraft } from './adminLibraryPanelModel'
@@ -169,7 +170,19 @@ function LibraryTableRow({ library, dragging, dragOver, onDragStart, onDragOver,
       </td>
       <td className="py-2 pr-3 font-medium text-ink-600">
         <div className="flex items-center gap-2">
-          {library.cover_url && <img src={library.cover_url} alt="" loading="lazy" decoding="async" className="h-10 w-8 rounded object-cover" />}
+          {library.cover_url && (
+            <img
+              src={imageURL(library.cover_url, library.updated_at)}
+              alt=""
+              loading="lazy"
+              decoding="async"
+              referrerPolicy="no-referrer"
+              className="h-10 w-8 rounded object-cover"
+              onError={(e) => {
+                e.currentTarget.style.visibility = 'hidden'
+              }}
+            />
+          )}
           <span>{library.name}</span>
         </div>
       </td>