feat(danmaku): 支持快捷填入当前片名并优化重新搜索机制

优化同步逻辑

internal/handler/media.go

@@ -170,7 +170,13 @@ func listLibrariesHandler(svc *service.Container) gin.HandlerFunc {
 								if acct == nil {
 									return
 								}
-								tmpMount := &model.EmbyMount{Base: model.Base{ID: v.MountID}}
+									tmpMount := &model.EmbyMount{
+										Base:           model.Base{ID: v.MountID},
+										AccountID:      v.AccountID,
+										RemoteViewID:   v.RemoteID,
+										CollectionType: v.CollectionType,
+										Name:           v.Library.Name,
+									}
 								itemTypes := remoteLibraryItemTypes(v.CollectionType)
 								if _, total, err := svc.EmbyRemote.RemoteLibraryMedia(ctx, tmpMount, acct, v.RemoteID, itemTypes, 0, 1); err == nil {
 									remotePayloads[i].Total = total
@@ -660,14 +666,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/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) == "" {
@@ -789,6 +820,7 @@ func (r *EmbyRemoteService) RemoteLatest(ctx context.Context, mount *model.EmbyM
 	if parentID != "" {
 		q.Set("ParentId", parentID)
 	}
+	q.Set("Fields", "Overview,Genres,ProviderIds,Path,SeriesPrimaryImage,DateCreated,DateLastMediaAdded,PremiereDate,ProductionYear,CommunityRating,CriticRating")
 	path := "/Users/" + url.PathEscape(r.remoteUserID(cfg)) + "/Items/Latest"
 	var out []map[string]any
 	if err := r.doGet(ctx, acct, cfg, path, q, &out); err != nil {

internal/service/emby_remote_web.go

@@ -180,21 +180,31 @@ func (r *EmbyRemoteService) MapRemoteItemToMedia(ctx context.Context, mount *mod
 	if _, rid, ok := DecodeEmbyRemoteID(seriesID); ok {
 		seriesID = rid
 	}
-	rating := remoteItemFloat(item, "CommunityRating")
-	if rating == 0 {
-		rating = remoteItemFloat(item, "CriticRating")
-	}
-	media := model.Media{
-		Base:         model.Base{ID: EncodeEmbyRemoteID(encodeScope, remoteID)},
-		Title:        remoteItemString(item, "Name"),
-		OriginalName: remoteItemString(item, "OriginalTitle"),
-		Overview:     remoteItemString(item, "Overview"),
-		Year:         remoteItemInt(item, "ProductionYear"),
-		Rating:       float32(rating),
-		Path:         remoteItemString(item, "Path"),
-		Genres:       remoteItemGenres(item),
-		ScrapeStatus: "done",
-	}
+		rating := remoteItemFloat(item, "CommunityRating")
+		if rating == 0 {
+			rating = remoteItemFloat(item, "CriticRating")
+		}
+		year := remoteItemInt(item, "ProductionYear")
+		if year == 0 {
+			year = remoteItemInt(item, "Year")
+		}
+		if year == 0 {
+			year = remoteItemInt(item, "SeriesProductionYear")
+		}
+		if year == 0 {
+			year = remoteItemInt(item, "SeriesYear")
+		}
+		media := model.Media{
+			Base:         model.Base{ID: EncodeEmbyRemoteID(encodeScope, remoteID)},
+			Title:        remoteItemString(item, "Name"),
+			OriginalName: remoteItemString(item, "OriginalTitle"),
+			Overview:     remoteItemString(item, "Overview"),
+			Year:         year,
+			Rating:       float32(rating),
+			Path:         remoteItemString(item, "Path"),
+			Genres:       remoteItemGenres(item),
+			ScrapeStatus: "done",
+		}
 	if date, ok := parseEmbyRemoteDate(remoteItemString(item, "DateCreated")); ok {
 		media.CreatedAt = date
 		media.UpdatedAt = date
@@ -561,6 +571,46 @@ func (r *EmbyRemoteService) RemoteLatestCards(ctx context.Context, mount *model.
 	if r.cache != nil && r.cache.GetJSON(ctx, cacheKey, &cached) {
 		return cached, nil
 	}
+
+	// 剧集类媒体库：直接拉取最新入库/更新的 Series 剧集本身（按上次添加集日期倒序）。
+	// 避免 Emby /Items/Latest 默认返回无年份/无系列海报的单集（Episode）。
+	if mount != nil && (mount.CollectionType == "tvshows" || mount.CollectionType == "tv") {
+		q := url.Values{}
+		q.Set("ParentId", remoteViewID)
+		q.Set("IncludeItemTypes", "Series")
+		q.Set("Recursive", "false")
+		q.Set("SortBy", "DateLastContentAdded")
+		q.Set("SortOrder", "Descending")
+		q.Set("Limit", strconv.Itoa(limit))
+		q.Set("Fields", "Overview,Genres,ProviderIds,Path,RecursiveItemCount,SeriesPrimaryImage,DateCreated,DateLastMediaAdded,PremiereDate,ProductionYear,CommunityRating,CriticRating")
+		var body struct {
+			Items []map[string]any `json:"Items"`
+		}
+		if err := r.doGet(ctx, acct, cfg, "/Users/"+url.PathEscape(r.remoteUserID(cfg))+"/Items", q, &body); err == nil && len(body.Items) > 0 {
+			cards := make([]SeriesCard, 0, len(body.Items))
+			for _, it := range body.Items {
+				RewriteEmbyRemoteIDs(it, mount.ID)
+				m := r.MapRemoteItemToMedia(ctx, mount, acct, cfg, it)
+				count := remoteItemInt(it, "RecursiveItemCount")
+				if count == 0 {
+					count = remoteItemInt(it, "ChildCount")
+				}
+				if count == 0 {
+					count = 1
+				}
+				var lastAdded *time.Time
+				if date, ok := parseEmbyRemoteDate(remoteItemString(it, "DateLastMediaAdded")); ok {
+					lastAdded = &date
+				}
+				cards = append(cards, SeriesCard{Key: m.ID, Rep: m, LinkMedia: m, Count: count, LastAddedAt: lastAdded})
+			}
+			if r.cache != nil {
+				r.cache.SetJSON(ctx, cacheKey, cards, r.remoteMediaCacheTTL())
+			}
+			return cards, nil
+		}
+	}
+
 	items, err := r.RemoteLatest(ctx, mount, acct, remoteViewID, limit)
 	if err != nil {
 		return nil, err
@@ -576,7 +626,11 @@ func (r *EmbyRemoteService) RemoteLatestCards(ctx context.Context, mount *model.
 			t := m.CreatedAt
 			lastAdded = &t
 		}
-		cards = append(cards, SeriesCard{Key: m.ID, Rep: m, LinkMedia: m, Count: 0, LastAddedAt: lastAdded})
+		count := remoteItemInt(it, "RecursiveItemCount")
+		if count == 0 {
+			count = remoteItemInt(it, "ChildCount")
+		}
+		cards = append(cards, SeriesCard{Key: m.ID, Rep: m, LinkMedia: m, Count: count, LastAddedAt: lastAdded})
 	}
 	if r.cache != nil {
 		r.cache.SetJSON(ctx, cacheKey, cards, r.remoteMediaCacheTTL())

internal/service/emby_remote_web_test.go

@@ -400,3 +400,130 @@ func TestRemoteSearchMedia(t *testing.T) {
 		t.Fatalf("expected 0 items due to HiddenLibraryIDs, got %d", len(hiddenFiltered))
 	}
 }
+
+func TestRemoteLatestCardsTvShowsYearAndPoster(t *testing.T) {
+	var requestedFields string
+	var requestedIncludeItemTypes string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requestedFields = r.URL.Query().Get("Fields")
+		requestedIncludeItemTypes = r.URL.Query().Get("IncludeItemTypes")
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"TotalRecordCount": 1,
+			"Items": []map[string]any{
+				{
+					"Id":             "series-100",
+					"Name":           "炒翻天",
+					"Type":           "Series",
+					"ProductionYear": 2024,
+					"ImageTags": map[string]any{
+						"Primary": "tag123",
+					},
+					"RecursiveItemCount": 12,
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	db := newServiceTestDB(t, &model.StrmAccount{}, &model.EmbyMount{})
+	repos := repository.New(db)
+	svc := NewEmbyRemoteService(&config.Config{}, zap.NewNop(), repos, NewCryptoService("", zap.NewNop()))
+
+	rawConfig, _ := json.Marshal(map[string]string{
+		"url":   server.URL,
+		"token": "fake-token",
+	})
+	acct := &model.StrmAccount{
+		Base:     model.Base{ID: "acct-tv"},
+		Name:     "tv-emby",
+		Provider: model.StrmProviderEmbyRemote,
+		Config:   string(rawConfig),
+		Enabled:  true,
+	}
+	_ = repos.StrmAccount.Create(t.Context(), acct)
+	mount := &model.EmbyMount{
+		Base:           model.Base{ID: "mount-tv"},
+		AccountID:      acct.ID,
+		RemoteViewID:   "view-tv",
+		RemoteViewName: "新番连载",
+		CollectionType: "tvshows",
+		Enabled:        true,
+	}
+	_ = repos.EmbyMount.Create(t.Context(), mount)
+
+	cards, err := svc.RemoteLatestCards(t.Context(), mount, acct, "view-tv", 10)
+	if err != nil {
+		t.Fatalf("RemoteLatestCards failed: %v", err)
+	}
+	if len(cards) != 1 {
+		t.Fatalf("expected 1 card, got %d", len(cards))
+	}
+	if cards[0].Rep.Year != 2024 {
+		t.Fatalf("expected Year 2024, got %d", cards[0].Rep.Year)
+	}
+	if cards[0].Count != 12 {
+		t.Fatalf("expected Count 12, got %d", cards[0].Count)
+	}
+	if cards[0].Rep.PosterURL == "" {
+		t.Fatalf("expected PosterURL not empty")
+	}
+	if requestedIncludeItemTypes != "Series" {
+		t.Fatalf("expected IncludeItemTypes=Series, got %q", requestedIncludeItemTypes)
+	}
+	if !strings.Contains(requestedFields, "ProductionYear") {
+		t.Fatalf("expected Fields to contain ProductionYear, got %q", requestedFields)
+	}
+}
+
+func TestRemoteLatestFields(t *testing.T) {
+	var requestedFields string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requestedFields = r.URL.Query().Get("Fields")
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode([]map[string]any{
+			{
+				"Id":             "movie-100",
+				"Name":           "测试电影",
+				"Type":           "Movie",
+				"ProductionYear": 2023,
+			},
+		})
+	}))
+	defer server.Close()
+
+	db := newServiceTestDB(t, &model.StrmAccount{}, &model.EmbyMount{})
+	repos := repository.New(db)
+	svc := NewEmbyRemoteService(&config.Config{}, zap.NewNop(), repos, NewCryptoService("", zap.NewNop()))
+
+	rawConfig, _ := json.Marshal(map[string]string{
+		"url":   server.URL,
+		"token": "fake-token",
+	})
+	acct := &model.StrmAccount{
+		Base:     model.Base{ID: "acct-movie"},
+		Name:     "movie-emby",
+		Provider: model.StrmProviderEmbyRemote,
+		Config:   string(rawConfig),
+		Enabled:  true,
+	}
+	_ = repos.StrmAccount.Create(t.Context(), acct)
+	mount := &model.EmbyMount{
+		Base:           model.Base{ID: "mount-movie"},
+		AccountID:      acct.ID,
+		RemoteViewID:   "view-movie",
+		CollectionType: "movies",
+		Enabled:        true,
+	}
+
+	items, err := svc.RemoteLatest(t.Context(), mount, acct, "view-movie", 10)
+	if err != nil {
+		t.Fatalf("RemoteLatest failed: %v", err)
+	}
+	if len(items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(items))
+	}
+	if !strings.Contains(requestedFields, "ProductionYear") {
+		t.Fatalf("expected Fields to contain ProductionYear, got %q", requestedFields)
+	}
+}

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

@@ -378,27 +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.log.Warn("删除网盘旧元数据失败，跳过删除继续上传新文件",
-				zap.String("task_id", task.ID),
-				zap.String("local_path", task.LocalPath),
-				zap.Error(err))
-			// 不 return：继续上传新文件，旧副本由下次同步清理
+			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

@@ -514,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()
 }
 
@@ -674,93 +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)
-	}
-
-	// 115 的扁平化列表（搜索底层）对 offset + limit 有 10000 的最大深度限制。
-	// 当扁平模式下的总文件数 >= 9500 时，强行拒绝继续扁平拉取，而是抛出降级错误，
-	// 让外层回退到使用普通的按目录并发递归（walkRemote），以免截断导致后排文件被误删/重传。
-	if totalCount >= 9500 {
-		return errFallbackToWalkRemote
-	}
-
-	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()
@@ -976,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)]
@@ -1132,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()
@@ -1140,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,
@@ -1415,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/components/DanmakuStage.tsx

@@ -28,6 +28,8 @@ type DanmakuStageProps = {
   search?: string | null
   /** Explicit danmaku library chosen by the user; null = auto-resolve. */
   episodeId?: number | string | null
+  /** Counter or token changed to trigger refetch even when search stays identical. */
+  searchTrigger?: number
   /** Called after each fetch attempt (success or error) finishes with metadata. */
   onLoaded?: (info: DanmakuLoadedInfo | null) => void
   /** Called when multiple anime matched and the user must pick one. */
@@ -50,6 +52,7 @@ export function DanmakuStage({
   area = 1,
   search = null,
   episodeId = null,
+  searchTrigger = 0,
   onLoaded,
   onCandidates,
 }: DanmakuStageProps) {
@@ -252,8 +255,8 @@ export function DanmakuStage({
       manager.unmount()
       managerRef.current = null
     }
-    // search / episodeId 变化时重新拉取弹幕（含媒体/开关切换）。
-  }, [media, videoRef, enabled, search, episodeId, onLoaded, onCandidates])
+    // search / episodeId / searchTrigger 变化时重新拉取弹幕（含媒体/开关切换）。
+  }, [media, videoRef, enabled, search, episodeId, searchTrigger, onLoaded, onCandidates])
 
   // Live renderer knobs: opacity / area / font size without recreating the
   // engine. font size additionally rescales currently visible comments.

web/src/components/PlayerDanmakuPanel.tsx

@@ -25,6 +25,8 @@ type PlayerDanmakuPanelProps = {
   candidates: DanmakuAnime[]
   /** Human-readable label of the currently selected library. */
   selectedSource?: string
+  /** Title used by auto-matching (e.g. anime title, media title or filename). */
+  autoMatchTitle?: string
   /** Loaded danmaku metadata (title, episode, count, match mode). */
   danmakuInfo?: DanmakuLoadedInfo | null
   onSelectEpisode: (episodeId: number, animeTitle: string, episodeTitle: string) => void
@@ -47,6 +49,7 @@ export function PlayerDanmakuPanel({
   onFontSizeChange,
   candidates,
   selectedSource,
+  autoMatchTitle,
   danmakuInfo,
   onSelectEpisode,
   onResetAuto,
@@ -203,7 +206,19 @@ export function PlayerDanmakuPanel({
 
       {/* 搜索弹幕 */}
       <div className="mb-4">
-        <div className="mb-1 text-xs text-white/60">搜索弹幕（留空 = 按视频名自动匹配）</div>
+        <div className="mb-1 flex items-center justify-between text-xs text-white/60">
+          <span>搜索弹幕（留空 = 按视频名自动匹配）</span>
+          {autoMatchTitle && (
+            <button
+              type="button"
+              onClick={() => setDraft(autoMatchTitle)}
+              className="text-[11px] text-rose-300 transition hover:text-rose-200"
+              title="填入当前识别到的视频名"
+            >
+              填入当前名
+            </button>
+          )}
+        </div>
         <div className="flex items-center gap-1.5">
           <input
             value={draft}
@@ -211,8 +226,8 @@ export function PlayerDanmakuPanel({
             onKeyDown={(e) => {
               if (e.key === 'Enter') onSearch(draft.trim())
             }}
-            placeholder="输入番剧或电影名…"
-            className="min-w-0 flex-1 rounded-lg border border-white/15 bg-white/5 px-2.5 py-1.5 text-xs outline-none placeholder:text-white/35 focus:border-rose-400/60"
+            placeholder={autoMatchTitle ? `自动匹配：${autoMatchTitle}` : '输入番剧或电影名…'}
+            className="min-w-0 flex-1 rounded-lg border border-white/15 bg-white/5 px-2.5 py-1.5 text-xs outline-none placeholder:text-white/40 focus:border-rose-400/60"
           />
           <button
             onClick={() => onSearch(draft.trim())}

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>

web/src/pages/PlayerPage.tsx

@@ -74,6 +74,7 @@ export function PlayerPage() {
   const [danmakuOpen, setDanmakuOpen] = useState(false)
   const [danmakuEnabled, setDanmakuEnabled] = useState(true)
   const [danmakuSearch, setDanmakuSearch] = useState<string | null>(null)
+  const [danmakuSearchTrigger, setDanmakuSearchTrigger] = useState(0)
   const [danmakuSearching, setDanmakuSearching] = useState(false)
   // 用户从候选列表选定的弹幕库；null = 自动匹配。
   const [danmakuEpisodeId, setDanmakuEpisodeId] = useState<number | string | null>(null)
@@ -141,6 +142,7 @@ export function PlayerPage() {
     setDanmakuEpisodeId(null)
     setDanmakuInfo(null)
     setDanmakuSearch(kw || null)
+    setDanmakuSearchTrigger((prev) => prev + 1)
   }, [])
 
   const danmakuLoaded = useCallback((info: DanmakuLoadedInfo | null) => {
@@ -164,6 +166,7 @@ export function PlayerPage() {
     setDanmakuSearching(true)
     // 展示当前所选来源（面板标题处可见）。
     setDanmakuSelectedSource(episodeTitle ? `${animeTitle}・${episodeTitle}` : animeTitle)
+    setDanmakuSearchTrigger((prev) => prev + 1)
   }, [])
 
   // 回到自动匹配（清除用户手动选择）。
@@ -174,6 +177,7 @@ export function PlayerPage() {
     setDanmakuSearch(null)
     setDanmakuSelectedSource('')
     setDanmakuInfo(null)
+    setDanmakuSearchTrigger((prev) => prev + 1)
   }, [])
 
   // 切换视频时重置媒体与弹幕状态，确保新视频自动重新识别并加载弹幕
@@ -549,6 +553,12 @@ export function PlayerPage() {
     toast.error('视频播放失败，请检查文件是否存在')
   }, [directOnly, hlsUnavailable, media, mode, params, setParams])
 
+  const danmakuAutoTitle =
+    danmakuInfo?.animeTitle ||
+    media?.original_name?.trim() ||
+    media?.title?.trim() ||
+    ''
+
   return (
     <div className="relative flex h-full w-full flex-1 flex-col overflow-hidden bg-black">
       <PlayerTopBar
@@ -580,6 +590,7 @@ export function PlayerPage() {
         danmakuArea={danmakuArea}
         danmakuSearch={danmakuSearch}
         danmakuEpisodeId={danmakuEpisodeId}
+        danmakuSearchTrigger={danmakuSearchTrigger}
         danmakuOpen={danmakuOpen}
         onToggleDanmaku={toggleDanmakuOpen}
         onDanmakuLoaded={danmakuLoaded}
@@ -619,6 +630,7 @@ export function PlayerPage() {
             onFontSizeChange={setDanmakuFontSize}
             candidates={danmakuCandidates}
             selectedSource={danmakuSelectedSource}
+            autoMatchTitle={danmakuAutoTitle}
             danmakuInfo={danmakuInfo}
             onSelectEpisode={danmakuSelectEpisode}
             onResetAuto={danmakuResetAuto}

web/src/pages/PlayerVideoStage.tsx

@@ -24,6 +24,7 @@ type PlayerVideoStageProps = {
   danmakuArea: number
   danmakuSearch: string | null
   danmakuEpisodeId: number | string | null
+  danmakuSearchTrigger?: number
   danmakuOpen: boolean
   onToggleDanmaku: () => void
   onDanmakuLoaded: (info: DanmakuLoadedInfo | null) => void
@@ -58,6 +59,7 @@ export function PlayerVideoStage({
   danmakuArea,
   danmakuSearch,
   danmakuEpisodeId,
+  danmakuSearchTrigger = 0,
   danmakuOpen,
   onToggleDanmaku,
   onDanmakuLoaded,
@@ -280,6 +282,7 @@ export function PlayerVideoStage({
               area={danmakuArea}
               search={danmakuSearch}
               episodeId={danmakuEpisodeId}
+              searchTrigger={danmakuSearchTrigger}
               onLoaded={onDanmakuLoaded}
               onCandidates={onDanmakuCandidates}
             />