fix: rename failed teaser retry action

fix: remove extra margin-right on logout button icon

.gitignore

@@ -23,10 +23,8 @@ tools/
 
 # 编译产物
 backend/server
-backend/server.*
 release/
 tsconfig.tsbuildinfo
-tmp/
 
 # 91 爬虫脚本独立运行时的默认输出文件（backend 跑时会显式 --output 到 backend/data/spider91/，所以不会落在这里）
 91porn_videos.json

CLAUDE.md

@@ -0,0 +1,135 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Common Commands
+
+### Full Local Development
+
+```bash
+npm install
+./start.sh
+```
+
+`./start.sh` starts the Go backend on `127.0.0.1:9192` and the frontend on `0.0.0.0:9191`. By default it builds the frontend and runs Vite preview mode. Use hot reload with:
+
+```bash
+FRONTEND_MODE=dev ./start.sh --restart
+```
+
+Useful variants:
+
+```bash
+./start.sh --status
+./start.sh --restart
+./start.sh --stop
+```
+
+### Frontend
+
+Run from the repository root:
+
+```bash
+npm run dev        # Vite dev server; default port comes from Vite unless overridden
+npm run dev:raw    # Vite dev server on 127.0.0.1:5173
+npm run build      # tsc -b && vite build
+npm run preview    # Vite preview; vite.config.ts uses port 9191
+npm run lint       # TypeScript no-emit check
+npm test           # node --import tsx --test tests/*.test.ts
+```
+
+Run one frontend test:
+
+```bash
+node --import tsx --test tests/previewIntent.test.ts
+```
+
+### Backend
+
+Run from `backend/` unless noted:
+
+```bash
+go run ./cmd/server
+go test ./... -count=1
+go build -o video-server ./cmd/server
+```
+
+Run one backend package or test:
+
+```bash
+go test ./internal/scanner -count=1
+go test ./internal/scanner -run TestParse -count=1
+```
+
+The backend requires Go 1.23+ and uses vendored dependencies in `backend/vendor/`, so keep `go mod vendor` in sync after dependency changes.
+
+### Release and Deployment
+
+```bash
+scripts/build-release.sh   # builds Linux amd64/arm64 release tarballs into release/
+sudo bash install.sh       # prebuilt installer flow used by README
+sudo bash deploy.sh        # build from current checkout and install systemd services
+```
+
+Docker uses the root `Dockerfile` and `docker-compose.yml`. The runtime image exposes port `9191` and stores persistent data under `/opt/video-site-91/data`.
+
+## Architecture Overview
+
+This is a private video aggregation site with a React/Vite frontend and a Go backend.
+
+### Frontend
+
+The frontend is a React 18 SPA under `src/`. `src/main.tsx` mounts `BrowserRouter`, `ToastProvider`, and `AuthProvider`, then renders `src/App.tsx`. `App.tsx` defines the public app routes (`/`, `/list`, `/shorts`, `/upload`, `/video/:id`) and admin routes under `/admin`; both main-site and admin pages are wrapped in `RequireAuth`, while `/login` is public.
+
+Frontend API calls are split by surface:
+
+- `src/data/videos.ts` calls the main authenticated API under `/api` and upload/proxy-related endpoints.
+- `src/admin/api.ts` is the admin API client for `/admin/api`, always sending cookies and raising `UnauthorizedError` on `401`.
+
+`vite.config.ts` proxies `/api`, `/p`, and `/admin/api` to `http://127.0.0.1:9192`, with frontend dev/preview served on port `9191` by default. The alias `@` maps to `src`.
+
+Styling is plain CSS loaded from `src/main.tsx` in token/base/layout/navigation/search/video/admin layers. Shared UI lives in `src/components`, page-level screens in `src/pages`, and admin screens in `src/admin`.
+
+### Backend
+
+The backend entrypoint is `backend/cmd/server/main.go`. It loads `config.yaml` or `VIDEO_CONFIG`, creates the SQLite catalog and preview directories, builds the app state, registers API routes, starts the nightly runner, and then asynchronously attaches configured external drives so slow upstream login checks do not block port binding.
+
+Important backend packages:
+
+- `internal/config`: YAML config loading and first-run admin credential setup.
+- `internal/catalog`: SQLite catalog, schema migration, video metadata, settings, tags, drive records, generation status, and deduplication state. It opens SQLite with WAL and a busy timeout.
+- `internal/drives`: provider abstraction. Implementations include `quark`, `p115`, `pikpak`, `wopan`, `onedrive`, `localstorage`, `localupload`, and `spider91`.
+- `internal/scanner`: recursively lists drive directories, parses filenames/tags, upserts catalog videos, applies skip-directory rules, and enqueues newly discovered videos.
+- `internal/preview`: ffprobe/ffmpeg thumbnail and teaser generation workers. Generated assets are local files under the configured preview directory.
+- `internal/fingerprint`: asynchronous sampled SHA-256 worker used for cross-drive duplicate detection.
+- `internal/proxy`: `/p/*` media serving. Some providers redirect with `302` to signed CDN URLs, while providers requiring backend-held headers are reverse-proxied with Range support.
+- `internal/api`: main API and admin API route handlers.
+- `internal/nightly`: daily pipeline for drive scans, spider91 crawl, migration, queue drain, and duplicate asset cleanup.
+- `internal/spider91migrate`: migration from spider91 downloads to a configured cloud drive.
+
+### Runtime Flow
+
+1. Admin adds or edits drives through `/admin/drives`, which persists drive config in the catalog.
+2. The server attaches the drive implementation into the proxy registry and can trigger scans.
+3. Scans convert provider files into catalog video rows, parse titles/authors/tags from filenames, and queue preview/fingerprint work.
+4. The frontend lists videos through `/api/home`, `/api/list`, `/api/video/:id`, and streams media through `/p/*` endpoints.
+5. The nightly runner performs the scheduled end-to-end maintenance pipeline; admins can trigger it manually through `/admin/api/jobs/nightly/run`.
+
+### Configuration and Data
+
+Backend defaults come from `backend/config.example.yaml`. On first backend start, `config.yaml` is created automatically if missing. Default local development paths are:
+
+- Backend listen address: `127.0.0.1:9192`
+- SQLite DB: `backend/data/video-site.db`
+- Generated previews/thumbs: `backend/data/previews`
+
+Docker and installer deployments rewrite config paths so data lives under `/opt/video-site-91/data` or the mounted `./data` directory.
+
+`VIDEO_FRONTEND_DIR` controls where the Go server looks for built frontend assets. If unset, it serves `./dist` when present. Backend routes (`/api`, `/admin/api`, `/p`) are excluded from the SPA fallback.
+
+## Notes for Changes
+
+- Main-site API routes and proxy routes require authentication; only login/setup and `/api/settings/theme` are intentionally public.
+- When adding a new drive provider, implement `internal/drives.Drive`, persist any needed config through catalog/admin APIs, attach it in `cmd/server`, and decide whether `/p/stream` should redirect or reverse-proxy in `internal/proxy`.
+- Generated thumbnails and teasers are local runtime assets; do not treat them as source files.
+- Frontend tests use Node's built-in test runner with `tsx`; TypeScript linting only checks `src` through the root `tsconfig.json`.

README.md

@@ -20,8 +20,8 @@
 
 ## 功能特性
 
-- **多后端支持** — 兼容 115 云盘、PikPak 云盘、123云盘、OneDrive、Google Drive 和本地存储
-- **低带宽播放** — 115 云盘、PikPak 云盘、123云盘、OneDrive 都支持302模式，在线播放视频时，不占用服务器带宽，播放体验不受服务器带宽影响；Google Drive 不支持302模式，走服务器中转，观看体验会受服务器带宽影响
+- **多后端支持** — 兼容 115 云盘、PikPak 云盘、OneDrive、Google Drive 和本地存储
+- **低带宽播放** — 115 云盘、PikPak 云盘、OneDrive 都支持302模式，在线播放视频时，不占用服务器带宽，播放体验不受服务器带宽影响；Google Drive 不支持302模式，走服务器中转，观看体验会受服务器带宽影响
 - **封面 & 预览片段** — 自动为每个视频生成封面图和预览片段，首页快速选片
 - **91 爬虫** — 内置爬虫，支持抓取 91 本月最热视频
 - **双主题** — 黑黄经典主题 / 粉白清新主题，随时切换
@@ -185,6 +185,7 @@ docker compose up -d         # 更新并重启
 | 文档 | 内容 |
 |------|------|
 | [backend/README.md](backend/README.md) | 后端实现、接口说明、网盘字段 |
+| [video-site-implementation-plan.md](video-site-implementation-plan.md) | 完整实现方案 |
 
 ---
 

backend/README.md

@@ -3,7 +3,7 @@
 视频聚合站的 Go 后端。提供三件事：
 
 1. 多家网盘统一抽象（夸克 / 115 / PikPak / 联通沃盘 / OneDrive / Google Drive / 本地存储）
-2. 视频元数据目录（SQLite）+ 扫描 + 预览视频预生成
+2. 视频元数据目录（SQLite）+ 扫描 + teaser 预生成
 3. REST API（前台）+ 管理后台 + 直链代理
 4. 标签池、视频隐藏、按网盘统计和详情页来源网盘类型展示能力
 
@@ -24,7 +24,7 @@ internal/
     googledrive/            Google Drive（OpenList 在线续期 + Google Drive API；播放走后端代理）
     localstorage/           本地目录扫描（服务器已有视频目录）
   scanner/                  扫目录 → 落库
-  preview/                  ffmpeg 抽封面和生成多段预览视频
+  preview/                  ffmpeg 抽封面和生成多段 teaser
   proxy/                    /p/stream/*、/p/preview/* 代理
   auth/                     管理员 session
   api/                      REST 路由
@@ -81,7 +81,7 @@ go run ./cmd/server 后端 9192
 
 ## 添加一个盘
 
-推荐在前端管理后台 `/admin/drives` 新增网盘。保存后会立即挂载并触发扫描；视频结果可在 `/admin/videos` 按网盘查看，每页 100 条，页面会同时显示各网盘预览视频已生成、待生成、失败数量。
+推荐在前端管理后台 `/admin/drives` 新增网盘。保存后会立即挂载并触发扫描；视频结果可在 `/admin/videos` 按网盘查看，每页 100 条，页面会同时显示各网盘 Teaser 已生成、待生成、失败数量。
 
 也可以直接调用后端接口：
 
@@ -149,18 +149,18 @@ Google Drive 按 OpenList 在线 API 调用 `https://api.oplist.org/googleui/ren
 
 `sampled_sha256` 是文件级去重：适合识别同一个视频文件被复制到 115 / PikPak / OneDrive 等不同网盘的情况。它不会删除任何网盘文件，也不用于识别转码、裁剪、加水印后的同源视频。
 
-封面和预览视频仍然优先生成，不等待指纹完成。夜间流水线最后会做一次重复资产清理：对 `size_bytes + sampled_sha256` 命中的非 canonical 视频，只删除本机生成的重复封面和预览视频，并把对应字段重置为 `pending`。网盘原文件和视频元数据记录不会被删除；如果 canonical 视频以后被移除，这些重复项会重新进入生成队列。
+封面和 teaser 仍然优先生成，不等待指纹完成。夜间流水线最后会做一次重复资产清理：对 `size_bytes + sampled_sha256` 命中的非 canonical 视频，只删除本机生成的重复封面和 teaser，并把对应字段重置为 `pending`。网盘原文件和视频元数据记录不会被删除；如果 canonical 视频以后被移除，这些重复项会重新进入生成队列。
 
 ## 管理能力
 
 - `/admin/drives`：新增、编辑、删除网盘，触发扫描。
-- `/admin/videos`：按网盘筛选视频，每页 100 条分页，查看各网盘预览视频统计，编辑标题/作者/分类/标签，单条或全量重生预览视频。
+- `/admin/videos`：按网盘筛选视频，每页 100 条分页，查看各网盘 Teaser 统计，编辑标题/作者/分类/标签，单条或全量重生 teaser。
 - `/admin/tags`：新增标签并用内置规则自动匹配已有视频；删除非系统标签时会从所有视频上同步移除该标签。
 - 播放页视频信息会展示来源网盘类型；同时提供“不再展示”，点击后会把视频标记为全局隐藏。隐藏视频不会再出现在首页、列表、搜索、相关推荐和详情接口中。目前没有管理后台恢复入口，如需恢复可把数据库里对应视频的 `hidden` 字段改回 `0`。
 
-## 预览视频生成
+## Teaser 生成
 
-scanner 扫到新视频会把 `(driveID, videoID)` 丢进 worker 队列。worker 会先用 `ffprobe` 探测时长，再用 `ffmpeg` 抽封面和生成无声预览视频：
+scanner 扫到新视频会把 `(driveID, videoID)` 丢进 worker 队列。worker 会先用 `ffprobe` 探测时长，再用 `ffmpeg` 抽封面和生成无声 teaser：
 
 ```
 ffmpeg -ss <起点> -headers "UA/Cookie/Referer" -i <直链> \
@@ -168,9 +168,9 @@ ffmpeg -ss <起点> -headers "UA/Cookie/Referer" -i <直链> \
        -movflags +faststart -y <local>.mp4
 ```
 
-当前策略是每段固定 3 秒；30 秒以下最多 3 段，30 秒及以上固定 4 段；长视频在 20% 到 80% 区间均匀取段。生成的预览视频和封面都只保存在本地 `data/previews/`，不会回写到网盘；旧数据中的 `preview_file_id` 会被忽略。
+当前策略是每段固定 3 秒；30 秒以下最多 3 段，30 秒及以上固定 4 段；长视频在 20% 到 80% 区间均匀取段。生成的 teaser 和封面都只保存在本地 `data/previews/`，不会回写到网盘；旧数据中的 `preview_file_id` 会被忽略。
 
-服务启动或网盘重新挂载时，如果预览视频开关已开启，后端会把历史 `pending` 任务重新入队，避免重启后长期停在“待生成”。OneDrive 扫盘和直链生成预览视频 / 封面时可能触发 Microsoft Graph 429、`TooManyRequests`、`activityLimitReached` 或 throttled 文本；后端会识别这类错误并让当前网盘进入冷却期，保留任务为 `pending`，避免连续请求触发更严重限流。扫盘阶段会按 `Retry-After` 或默认冷却时间等待后继续当前目录。
+服务启动或网盘重新挂载时，如果 Teaser 开关已开启，后端会把历史 `pending` 任务重新入队，避免重启后长期停在“待生成”。OneDrive 扫盘和直链生成 teaser / 封面时可能触发 Microsoft Graph 429、`TooManyRequests`、`activityLimitReached` 或 throttled 文本；后端会识别这类错误并让当前网盘进入冷却期，保留任务为 `pending`，避免连续请求触发更严重限流。扫盘阶段会按 `Retry-After` 或默认冷却时间等待后继续当前目录。
 
 前端卡片的 `previewSrc` 统一指向 `/p/preview/<videoID>`，后端只从本地 `preview_local` 文件读取。
 

backend/cmd/server/main_spider91_test.go

@@ -38,7 +38,6 @@ func TestSpider91IntCredFallbacks(t *testing.T) {
 func TestSpider91UploadDriveIDDoesNotAutoSelectTarget(t *testing.T) {
 	reg := proxy.NewRegistry()
 	reg.Set("p115-one", &spider91UploadTargetFakeDrive{id: "p115-one", kind: "p115"})
-	reg.Set("p123-one", &spider91UploadTargetFakeDrive{id: "p123-one", kind: "p123"})
 	reg.Set("onedrive-one", &spider91UploadTargetFakeDrive{id: "onedrive-one", kind: "onedrive"})
 
 	app := &App{registry: reg}
@@ -51,11 +50,6 @@ func TestSpider91UploadDriveIDDoesNotAutoSelectTarget(t *testing.T) {
 		t.Fatalf("explicit upload target = %q, want p115-one", got)
 	}
 
-	app.spider91UploadDriveID = "p123-one"
-	if got := app.Spider91UploadDriveID(); got != "p123-one" {
-		t.Fatalf("explicit p123 upload target = %q, want p123-one", got)
-	}
-
 	app.spider91UploadDriveID = "onedrive-one"
 	if got := app.Spider91UploadDriveID(); got != "onedrive-one" {
 		t.Fatalf("explicit onedrive upload target = %q, want onedrive-one", got)

backend/cmd/server/main_test.go

@@ -225,170 +225,6 @@ func TestRegisterPreviewWorkersBackfillsHistoricalFingerprints(t *testing.T) {
 	t.Fatalf("fingerprint status=%q sampled=%q, want ready with hash", got.FingerprintStatus, got.SampledSHA256)
 }
 
-func TestStopDriveTasksCancelsQueuedTasksAndReplacesWorkers(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cat, err := catalog.Open(t.TempDir() + "/catalog.db")
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := cat.Close(); err != nil {
-			t.Fatalf("close catalog: %v", err)
-		}
-	})
-
-	drv := &serverFakeDrive{}
-	registry := proxy.NewRegistry()
-	registry.Set("drive-id", drv)
-
-	gen := &serverFakeTeaserGenerator{}
-	oldWorker := preview.NewWorker(gen, cat, drv)
-	oldThumbWorker := preview.NewThumbWorker(gen, cat, drv)
-	oldFingerprintWorker := fingerprint.NewWorker(cat, drv, fingerprint.Config{})
-	oldCanceled := make(chan struct{})
-
-	app := &App{
-		cfg:                &config.Config{},
-		cat:                cat,
-		registry:           registry,
-		workers:            map[string]*preview.Worker{"drive-id": oldWorker},
-		thumbWorkers:       map[string]*preview.ThumbWorker{"drive-id": oldThumbWorker},
-		fingerprintWorkers: map[string]*fingerprint.Worker{"drive-id": oldFingerprintWorker},
-		cancels: map[string]context.CancelFunc{
-			"drive-id": func() { close(oldCanceled) },
-		},
-		scanQueued:          map[string]bool{"drive-id": true},
-		fingerprintQueueing: map[string]bool{"drive-id": true},
-	}
-	taskCtx, done := app.registerDriveTaskContext(ctx, "drive-id")
-	defer done()
-
-	if !app.stopDriveTasks(ctx, "drive-id") {
-		t.Fatal("stopDriveTasks returned false, want true")
-	}
-	select {
-	case <-oldCanceled:
-	case <-time.After(time.Second):
-		t.Fatal("old worker cancel was not called")
-	}
-	if err := taskCtx.Err(); err == nil {
-		t.Fatal("registered drive task context was not canceled")
-	}
-	if app.scanQueued["drive-id"] {
-		t.Fatal("scan queue marker was not cleared")
-	}
-	if app.fingerprintQueueing["drive-id"] {
-		t.Fatal("fingerprint queue marker was not cleared")
-	}
-
-	app.mu.Lock()
-	newWorker := app.workers["drive-id"]
-	newThumbWorker := app.thumbWorkers["drive-id"]
-	newFingerprintWorker := app.fingerprintWorkers["drive-id"]
-	newCancel := app.cancels["drive-id"]
-	app.mu.Unlock()
-	if newWorker == nil || newWorker == oldWorker {
-		t.Fatalf("preview worker was not replaced")
-	}
-	if newThumbWorker == nil || newThumbWorker == oldThumbWorker {
-		t.Fatalf("thumb worker was not replaced")
-	}
-	if newFingerprintWorker == nil || newFingerprintWorker == oldFingerprintWorker {
-		t.Fatalf("fingerprint worker was not replaced")
-	}
-	if newCancel == nil {
-		t.Fatalf("replacement worker cancel was not registered")
-	}
-	newCancel()
-}
-
-func TestDriveGenerationStatusUsesWorkerQueueNotPendingCatalogRows(t *testing.T) {
-	ctx := context.Background()
-	cat, err := catalog.Open(t.TempDir() + "/catalog.db")
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := cat.Close(); err != nil {
-			t.Fatalf("close catalog: %v", err)
-		}
-	})
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &catalog.Video{
-		ID:            "pending-thumb",
-		DriveID:       "drive-id",
-		FileID:        "file-id",
-		Title:         "Pending Thumb",
-		PreviewStatus: "ready",
-		PublishedAt:   now,
-		CreatedAt:     now,
-		UpdatedAt:     now,
-	}); err != nil {
-		t.Fatalf("seed video: %v", err)
-	}
-	if err := cat.UpdateVideoMeta(ctx, "pending-thumb", catalog.VideoMetaPatch{ThumbnailStatus: "pending"}); err != nil {
-		t.Fatalf("mark thumbnail pending: %v", err)
-	}
-
-	thumbWorker := preview.NewThumbWorker(&serverFakeTeaserGenerator{}, cat, &serverFakeDrive{})
-	app := &App{
-		cat:                cat,
-		workers:            map[string]*preview.Worker{},
-		thumbWorkers:       map[string]*preview.ThumbWorker{"drive-id": thumbWorker},
-		fingerprintWorkers: map[string]*fingerprint.Worker{},
-	}
-
-	status := app.driveGenerationStatuses()["drive-id"].Thumbnail
-	if status.State != "idle" || status.QueueLength != 0 {
-		t.Fatalf("thumbnail status = %#v, want idle with empty worker queue", status)
-	}
-}
-
-func TestRegenFailedThumbnailsQueuesPendingRowsAfterStop(t *testing.T) {
-	ctx := context.Background()
-	cat, err := catalog.Open(t.TempDir() + "/catalog.db")
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := cat.Close(); err != nil {
-			t.Fatalf("close catalog: %v", err)
-		}
-	})
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &catalog.Video{
-		ID:            "pending-thumb",
-		DriveID:       "drive-id",
-		FileID:        "file-id",
-		Title:         "Pending Thumb",
-		PreviewStatus: "ready",
-		PublishedAt:   now,
-		CreatedAt:     now,
-		UpdatedAt:     now,
-	}); err != nil {
-		t.Fatalf("seed video: %v", err)
-	}
-	if err := cat.UpdateVideoMeta(ctx, "pending-thumb", catalog.VideoMetaPatch{ThumbnailStatus: "pending"}); err != nil {
-		t.Fatalf("mark thumbnail pending: %v", err)
-	}
-
-	thumbWorker := preview.NewThumbWorker(&serverFakeTeaserGenerator{}, cat, &serverFakeDrive{})
-	app := &App{
-		cat:          cat,
-		thumbWorkers: map[string]*preview.ThumbWorker{"drive-id": thumbWorker},
-	}
-
-	app.regenFailedThumbnails(ctx, "drive-id")
-
-	if got := thumbWorker.Status().QueueLength; got != 1 {
-		t.Fatalf("thumb queue length = %d, want pending row re-enqueued", got)
-	}
-}
-
 func TestRunScanStartsFingerprintBeforeThumbnailAndPreviewDrain(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -943,177 +779,6 @@ func TestCleanupDriveVideosForDeleteRemovesRowsAndGeneratedAssetsOnly(t *testing
 	}
 }
 
-func TestDeleteVideoRemovesGeneratedAssetsKeepsLocalOriginalAndTombstones(t *testing.T) {
-	ctx := context.Background()
-	root := t.TempDir()
-	localDir := filepath.Join(root, "previews")
-	originalDir := filepath.Join(root, "local-videos")
-	originalVideo := filepath.Join(originalDir, "clip.mp4")
-	if err := os.MkdirAll(originalDir, 0o755); err != nil {
-		t.Fatalf("mkdir original dir: %v", err)
-	}
-	if err := os.WriteFile(originalVideo, []byte("original"), 0o644); err != nil {
-		t.Fatalf("write original: %v", err)
-	}
-
-	cat, err := catalog.Open(filepath.Join(t.TempDir(), "catalog.db"))
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() { _ = cat.Close() })
-	if err := cat.UpsertDrive(ctx, &catalog.Drive{
-		ID:            "local-main",
-		Kind:          "localstorage",
-		Name:          "Local",
-		RootID:        "/",
-		Credentials:   map[string]string{"path": originalDir},
-		TeaserEnabled: true,
-	}); err != nil {
-		t.Fatalf("seed drive: %v", err)
-	}
-
-	previewPath := filepath.Join(localDir, "localstorage-local-main-file.mp4")
-	thumbPath := filepath.Join(localDir, "thumbs", "localstorage-local-main-file.jpg")
-	for _, path := range []string{previewPath, thumbPath} {
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatalf("mkdir %s: %v", path, err)
-		}
-		if err := os.WriteFile(path, []byte("generated"), 0o644); err != nil {
-			t.Fatalf("write %s: %v", path, err)
-		}
-	}
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &catalog.Video{
-		ID:                "localstorage-local-main-file",
-		DriveID:           "local-main",
-		FileID:            "file",
-		FileName:          "clip.mp4",
-		SampledSHA256:     "sampled",
-		FingerprintStatus: "ready",
-		Title:             "Local File",
-		PreviewLocal:      previewPath,
-		PreviewStatus:     "ready",
-		ThumbnailURL:      "/p/thumb/localstorage-local-main-file",
-		Size:              123,
-		PublishedAt:       now,
-		CreatedAt:         now,
-		UpdatedAt:         now,
-	}); err != nil {
-		t.Fatalf("seed video: %v", err)
-	}
-
-	app := &App{
-		cfg: &config.Config{Storage: config.Storage{LocalPreviewDir: localDir}},
-		cat: cat,
-	}
-	result, err := app.deleteVideo(ctx, "localstorage-local-main-file")
-	if err != nil {
-		t.Fatalf("delete video: %v", err)
-	}
-	if !result.OK || result.DeletedSource {
-		t.Fatalf("delete result = %#v, want ok without source deletion", result)
-	}
-	if _, err := cat.GetVideo(ctx, "localstorage-local-main-file"); err != sql.ErrNoRows {
-		t.Fatalf("deleted video lookup error = %v, want sql.ErrNoRows", err)
-	}
-	deleted, err := cat.IsDeletedVideoCandidate(ctx, "localstorage-local-main-file", "local-main", "file", "", "clip.mp4", 123)
-	if err != nil {
-		t.Fatalf("check tombstone: %v", err)
-	}
-	if !deleted {
-		t.Fatal("deleted video tombstone missing")
-	}
-	for _, path := range []string{previewPath, thumbPath} {
-		if _, err := os.Stat(path); !os.IsNotExist(err) {
-			t.Fatalf("generated asset %s still exists, stat err=%v", path, err)
-		}
-	}
-	if _, err := os.Stat(originalVideo); err != nil {
-		t.Fatalf("original local video was removed: %v", err)
-	}
-}
-
-func TestDeleteVideoRemovesSpider91SourceFile(t *testing.T) {
-	ctx := context.Background()
-	root := t.TempDir()
-	localDir := filepath.Join(root, "previews")
-	cat, err := catalog.Open(filepath.Join(t.TempDir(), "catalog.db"))
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() { _ = cat.Close() })
-
-	if err := cat.UpsertDrive(ctx, &catalog.Drive{
-		ID:            "spider-main",
-		Kind:          spider91.Kind,
-		Name:          "Spider",
-		RootID:        "/",
-		TeaserEnabled: true,
-	}); err != nil {
-		t.Fatalf("seed drive: %v", err)
-	}
-	app := &App{
-		cfg: &config.Config{Storage: config.Storage{LocalPreviewDir: localDir}},
-		cat: cat,
-	}
-	sourceDir := app.spider91DriveDir("spider-main")
-	sourceVideo := filepath.Join(sourceDir, "videos", "source.mp4")
-	sourceThumb := filepath.Join(sourceDir, "thumbs", "source.jpg")
-	previewPath := filepath.Join(localDir, "spider91-spider-main-source.mp4")
-	commonThumb := filepath.Join(localDir, "thumbs", "spider91-spider-main-source.jpg")
-	for _, path := range []string{sourceVideo, sourceThumb, previewPath, commonThumb} {
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatalf("mkdir %s: %v", path, err)
-		}
-		if err := os.WriteFile(path, []byte("file"), 0o644); err != nil {
-			t.Fatalf("write %s: %v", path, err)
-		}
-	}
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &catalog.Video{
-		ID:            "spider91-spider-main-source",
-		DriveID:       "spider-main",
-		FileID:        "source.mp4",
-		FileName:      "source.mp4",
-		Ext:           "mp4",
-		Title:         "Spider Source",
-		PreviewLocal:  previewPath,
-		PreviewStatus: "ready",
-		ThumbnailURL:  "/p/thumb/spider91-spider-main-source",
-		Size:          456,
-		PublishedAt:   now,
-		CreatedAt:     now,
-		UpdatedAt:     now,
-	}); err != nil {
-		t.Fatalf("seed video: %v", err)
-	}
-
-	result, err := app.deleteVideo(ctx, "spider91-spider-main-source")
-	if err != nil {
-		t.Fatalf("delete spider video: %v", err)
-	}
-	if !result.OK || !result.DeletedSource {
-		t.Fatalf("delete result = %#v, want source deleted", result)
-	}
-	for _, path := range []string{sourceVideo, sourceThumb, previewPath, commonThumb} {
-		if _, err := os.Stat(path); !os.IsNotExist(err) {
-			t.Fatalf("deleted file %s still exists, stat err=%v", path, err)
-		}
-	}
-	if _, err := cat.GetVideo(ctx, "spider91-spider-main-source"); err != sql.ErrNoRows {
-		t.Fatalf("deleted video lookup error = %v, want sql.ErrNoRows", err)
-	}
-	deleted, err := cat.IsVideoDeleted(ctx, "spider91-spider-main-source")
-	if err != nil {
-		t.Fatalf("check tombstone: %v", err)
-	}
-	if !deleted {
-		t.Fatal("deleted spider91 video tombstone missing")
-	}
-}
-
 func TestCleanupDriveVideosForDeleteSpider91RemovesCrawledDirAndOriginRecords(t *testing.T) {
 	ctx := context.Background()
 	root := t.TempDir()

backend/config.example.yaml

@@ -22,7 +22,7 @@ server:
 storage:
   # SQLite 数据库文件路径
   db_path: "./data/video-site.db"
-  # 本地预览视频和封面目录
+  # 本地 teaser 和封面目录
   local_preview_dir: "./data/previews"
 
 scanner:
@@ -38,24 +38,24 @@ scanner:
 nightly:
   # 凌晨流水线触发整点（0-23），默认 1 即每天 01:00。流程：
   #   Phase 1  扫所有非 spider91 / 非 localupload 网盘 → 检测新增 / 删除
-  #            → 入队封面和预览视频 → 等所有队列 idle
-  #   Phase 2  spider91 爬虫（如配置）→ 入队预览视频 → 等队列 idle
+  #            → 入队封面和 teaser → 等所有队列 idle
+  #   Phase 2  spider91 爬虫（如配置）→ 入队 teaser → 等队列 idle
   #   Phase 3  spider91 → 云盘迁移（一次性 sweep）
   cron_hour: 1
   # 单次流水线总耗时上限（软超时）；超过后当前 phase 跑完不启动后续 phase。
   max_duration: 6h
 
 preview:
-  # 是否启用 ffmpeg 抽帧生成预览视频
+  # 是否启用 ffmpeg 抽帧生成 teaser
   enabled: true
   # ffmpeg / ffprobe 可执行文件名或绝对路径
   ffmpeg_path: "ffmpeg"
   ffprobe_path: "ffprobe"
-  # 预览视频每段时长（秒），实际生成时每段最多 3 秒
+  # teaser 每段时长（秒），实际生成时每段最多 3 秒
   duration_seconds: 3
   # 兼容旧配置；当前 30 秒以下最多 3 段，30 秒及以上固定 4 段
   segments: 3
-  # 预览视频宽度
+  # teaser 视频宽度
   width: 480
 
 # 盘列表。上线后请通过管理后台添加，本文件可留空。

backend/internal/api/admin.go

@@ -39,30 +39,27 @@ type AdminServer struct {
 	SetupRequired func() bool
 	// OnSetup 持久化首次部署时设置的管理员账号密码，并更新运行中认证器。
 	OnSetup func(username, password string) error
-	// LocalPreviewDir is the local directory that stores generated preview videos and thumbs.
+	// LocalPreviewDir is the local directory that stores generated teasers and thumbs.
 	LocalPreviewDir string
 	// Hooks：外层注入实际执行者
 	OnDriveSaved               func(driveID string) error
 	OnDriveDeleteCleanup       func(ctx context.Context, driveID string) (int, error)
 	OnDriveRemoved             func(driveID string)
 	OnScanRequested            func(driveID string)
-	OnStopDriveTasks           func(driveID string) bool
-	OnStopAllTasks             func() int
 	OnRegenPreview             func(videoID string)
 	OnRegenAllPreviews         func()
 	OnRegenFailedPreviews      func(driveID string)
 	OnRegenFailedThumbnails    func(driveID string)
 	OnRegenFailedFingerprints  func(driveID string)
-	OnDeleteVideo              func(ctx context.Context, videoID string) (DeleteVideoResult, error)
 	GetDriveGenerationStatuses func() map[string]DriveGenerationStatuses
-	// OnTeaserEnabledChanged 在 per-drive 预览视频开关被切换后调用。
-	// enabled=true 时上层应该重新把 pending 预览视频入队（类似旧的全局开关从关到开）；
+	// OnTeaserEnabledChanged 在 per-drive teaser 开关被切换后调用。
+	// enabled=true 时上层应该重新把 pending teaser 入队（类似旧的全局开关从关到开）；
 	// enabled=false 时通常不用做事 —— worker 入队前会再次查 catalog，自然停止。
 	OnTeaserEnabledChanged func(driveID string, enabled bool)
 	// Theme 读写（"dark" | "pink"）
 	GetTheme func() string
 	SetTheme func(theme string) error
-	// Spider91 → 115/123/PikPak/OneDrive 上传目标 drive ID 读写
+	// Spider91 → 115/PikPak 上传目标 drive ID 读写
 	GetSpider91UploadDriveID func() string
 	SetSpider91UploadDriveID func(driveID string) error
 	// OnRunNightlyJob 触发一次完整的凌晨流水线（Phase1 扫盘 + Phase2 91 爬虫 +
@@ -108,11 +105,6 @@ type NightlyJobStatus struct {
 	LastFinishedAt string `json:"lastFinishedAt,omitempty"`
 }
 
-type DeleteVideoResult struct {
-	OK            bool `json:"ok"`
-	DeletedSource bool `json:"deletedSource"`
-}
-
 func (a *AdminServer) Register(r chi.Router) {
 	r.Route("/admin/api", func(r chi.Router) {
 		// 登录、登出和首次部署初始化不需要鉴权
@@ -134,7 +126,6 @@ func (a *AdminServer) Register(r chi.Router) {
 			r.Get("/drives/p123/qr/{uniID}", a.handleP123QRStatus)
 			r.Delete("/drives/{id}", a.handleDeleteDrive)
 			r.Post("/drives/{id}/rescan", a.handleRescan)
-			r.Post("/drives/{id}/tasks/stop", a.handleStopDriveTasks)
 			r.Post("/drives/{id}/teaser-enabled", a.handleSetDriveTeaserEnabled)
 			r.Post("/drives/{id}/skip-dirs", a.handleSetDriveSkipDirs)
 			r.Get("/drives/{id}/dirtree", a.handleListDriveDirTree)
@@ -145,7 +136,6 @@ func (a *AdminServer) Register(r chi.Router) {
 			// 视频
 			r.Get("/videos", a.handleAdminListVideos)
 			r.Put("/videos/{id}", a.handleUpdateVideo)
-			r.Delete("/videos/{id}", a.handleDeleteVideo)
 			r.Post("/videos/regen-preview", a.handleRegenAllPreviews)
 			r.Post("/videos/{id}/regen-preview", a.handleRegenPreview)
 
@@ -162,7 +152,6 @@ func (a *AdminServer) Register(r chi.Router) {
 			r.Get("/update/check", a.handleCheckUpdate)
 			r.Get("/jobs/nightly/status", a.handleNightlyJobStatus)
 			r.Post("/jobs/nightly/run", a.handleRunNightlyJob)
-			r.Post("/tasks/stop", a.handleStopAllTasks)
 		})
 	})
 }
@@ -407,7 +396,7 @@ func (a *AdminServer) handleListDrives(w http.ResponseWriter, r *http.Request) {
 		Status        string `json:"status"`
 		LastError     string `json:"lastError,omitempty"`
 		HasCredential bool   `json:"hasCredential"`
-		// TeaserEnabled 控制是否给本盘生成预览视频/封面。前端用它在网盘列表/编辑表单展示开关状态。
+		// TeaserEnabled 控制是否给本盘生成 teaser/封面。前端用它在网盘列表/编辑表单展示开关状态。
 		TeaserEnabled bool `json:"teaserEnabled"`
 		// SkipDirIDs 是用户在 admin 配置的"扫描跳过目录"集合（drive 侧目录 fileID）。
 		// 前端用它在"设置跳过目录"弹窗里回显已选项；JSON 字段名 camelCase 与
@@ -502,7 +491,7 @@ type upsertDriveReq struct {
 	// Deprecated: 扫描起点已固定为 rootId；保留字段只为兼容旧客户端请求体。
 	ScanRootID  string            `json:"scanRootId"`
 	Credentials map[string]string `json:"credentials"`
-	// TeaserEnabled 是 per-drive 预览视频/封面生成开关。
+	// TeaserEnabled 是 per-drive teaser/封面生成开关。
 	// 用 *bool 区分 "未传" / "传了 false"：未传时表示客户端不打算改这个字段，
 	// 沿用 catalog 现有值；新建时未传一律默认开启（true）。
 	TeaserEnabled *bool `json:"teaserEnabled,omitempty"`
@@ -681,18 +670,6 @@ func (a *AdminServer) handleRescan(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusAccepted, map[string]any{"ok": true})
 }
 
-func (a *AdminServer) handleStopDriveTasks(w http.ResponseWriter, r *http.Request) {
-	id := chi.URLParam(r, "id")
-	stopped := false
-	if a.OnStopDriveTasks != nil {
-		stopped = a.OnStopDriveTasks(id)
-	}
-	writeJSON(w, http.StatusAccepted, map[string]any{
-		"ok":      true,
-		"stopped": stopped,
-	})
-}
-
 func (a *AdminServer) p123QRClient() *p123.QRClient {
 	return p123.NewQRClient(p123.QRConfig{
 		UserAPIBaseURL: a.P123UserAPIBaseURL,
@@ -745,18 +722,6 @@ func (a *AdminServer) handleNightlyJobStatus(w http.ResponseWriter, r *http.Requ
 	writeJSON(w, http.StatusOK, a.nightlyJobStatus())
 }
 
-func (a *AdminServer) handleStopAllTasks(w http.ResponseWriter, r *http.Request) {
-	stoppedDrives := 0
-	if a.OnStopAllTasks != nil {
-		stoppedDrives = a.OnStopAllTasks()
-	}
-	writeJSON(w, http.StatusAccepted, map[string]any{
-		"ok":            true,
-		"stoppedDrives": stoppedDrives,
-		"status":        a.nightlyJobStatus(),
-	})
-}
-
 func (a *AdminServer) nightlyJobStatus() NightlyJobStatus {
 	if a.GetNightlyJobStatus == nil {
 		return NightlyJobStatus{State: "idle"}
@@ -773,11 +738,11 @@ type teaserEnabledReq struct {
 	Enabled bool `json:"enabled"`
 }
 
-// handleSetDriveTeaserEnabled 切换某盘的预览视频生成开关。
+// handleSetDriveTeaserEnabled 切换某盘的 teaser 生成开关。
 //
 // 行为：
 //   - 写 catalog.drives.teaser_enabled
-//   - 调 OnTeaserEnabledChanged（main 注入；从关到开时会重新入队 pending 预览视频）
+//   - 调 OnTeaserEnabledChanged（main 注入；从关到开时会重新入队 pending teaser）
 //   - 返回切换后的新值，方便前端乐观更新但又能以服务端为准
 //
 // 与 upsertDrive 的区别：那条接口要重传 kind / name / rootId 等，开关切换不该
@@ -899,7 +864,6 @@ func (a *AdminServer) handleAdminListVideos(w http.ResponseWriter, r *http.Reque
 		size = 100
 	}
 	items, total, err := a.Catalog.ListVideos(r.Context(), catalog.ListParams{
-		Keyword:  q.Get("keyword"),
 		DriveID:  q.Get("driveId"),
 		Page:     page,
 		PageSize: size,
@@ -1038,36 +1002,6 @@ func (a *AdminServer) handleUpdateVideo(w http.ResponseWriter, r *http.Request)
 	writeJSON(w, http.StatusOK, v)
 }
 
-func (a *AdminServer) handleDeleteVideo(w http.ResponseWriter, r *http.Request) {
-	id := strings.TrimSpace(chi.URLParam(r, "id"))
-	if id == "" {
-		writeErr(w, http.StatusBadRequest, errors.New("invalid video id"))
-		return
-	}
-	var (
-		result DeleteVideoResult
-		err    error
-	)
-	if a.OnDeleteVideo != nil {
-		result, err = a.OnDeleteVideo(r.Context(), id)
-	} else {
-		err = a.Catalog.DeleteVideoWithTombstone(r.Context(), id)
-		result = DeleteVideoResult{OK: err == nil}
-	}
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			writeErr(w, http.StatusNotFound, err)
-			return
-		}
-		writeErr(w, http.StatusInternalServerError, err)
-		return
-	}
-	if !result.OK {
-		result.OK = true
-	}
-	writeJSON(w, http.StatusOK, result)
-}
-
 func (a *AdminServer) handleRegenPreview(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	if a.OnRegenPreview != nil {
@@ -1092,7 +1026,7 @@ func (a *AdminServer) handleRegenFailedPreviews(w http.ResponseWriter, r *http.R
 }
 
 // handleRegenFailedThumbnails 触发某 drive 下所有 thumbnail_status=failed 的封面
-// 重新入队生成。和 handleRegenFailedPreviews 行为对称（一个管预览视频，一个管封面）。
+// 重新入队生成。和 handleRegenFailedPreviews 行为对称（一个管 teaser，一个管封面）。
 //
 // 立即返回 202；实际执行在后台 goroutine 跑，状态可在下次 GET /admin/api/drives
 // 的 thumbnailFailedCount / thumbnailGenerationStatus 看变化。
@@ -1105,7 +1039,7 @@ func (a *AdminServer) handleRegenFailedThumbnails(w http.ResponseWriter, r *http
 }
 
 // handleRegenFailedFingerprints triggers regeneration for all failed sampled
-// fingerprints on a drive. It mirrors the failed preview-video/thumbnail retry endpoints.
+// fingerprints on a drive. It mirrors the failed teaser/thumbnail retry endpoints.
 func (a *AdminServer) handleRegenFailedFingerprints(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	if a.OnRegenFailedFingerprints != nil {
@@ -1119,7 +1053,7 @@ func (a *AdminServer) handleRegenFailedFingerprints(w http.ResponseWriter, r *ht
 // settingsDTO 是 GET/PUT /admin/api/settings 的入参/出参。
 //
 // 注意：早期的全局 previewEnabled 字段已经下沉为每盘 teaser_enabled，
-// 不再出现在这里；前端要切换某个盘的预览视频生成请用 POST /admin/api/drives 上传
+// 不再出现在这里；前端要切换某个盘的 teaser 生成请用 POST /admin/api/drives 上传
 // teaserEnabled 字段。保留 settings 用作主题、spider91 上传目标这类全局配置。
 type settingsDTO struct {
 	Theme                 string `json:"theme"`

backend/internal/api/admin_test.go

@@ -296,75 +296,6 @@ func TestHandleNightlyJobStatusDefaultsToIdle(t *testing.T) {
 	}
 }
 
-func TestHandleStopDriveTasksInvokesHookWithDriveID(t *testing.T) {
-	calledWith := ""
-	server := &AdminServer{
-		OnStopDriveTasks: func(driveID string) bool {
-			calledWith = driveID
-			return true
-		},
-	}
-
-	req := httptest.NewRequest(http.MethodPost, "/admin/api/drives/PikPak/tasks/stop", nil)
-	rctx := chi.NewRouteContext()
-	rctx.URLParams.Add("id", "PikPak")
-	req = req.WithContext(context.WithValue(req.Context(), chi.RouteCtxKey, rctx))
-	rr := httptest.NewRecorder()
-	server.handleStopDriveTasks(rr, req)
-
-	if rr.Code != http.StatusAccepted {
-		t.Fatalf("status = %d, body = %s", rr.Code, rr.Body.String())
-	}
-	if calledWith != "PikPak" {
-		t.Fatalf("hook called with %q, want PikPak", calledWith)
-	}
-	var got struct {
-		OK      bool `json:"ok"`
-		Stopped bool `json:"stopped"`
-	}
-	if err := json.NewDecoder(rr.Body).Decode(&got); err != nil {
-		t.Fatalf("decode: %v", err)
-	}
-	if !got.OK || !got.Stopped {
-		t.Fatalf("response = %#v, want stopped", got)
-	}
-}
-
-func TestHandleStopAllTasksInvokesHookAndReturnsStatus(t *testing.T) {
-	called := false
-	server := &AdminServer{
-		OnStopAllTasks: func() int {
-			called = true
-			return 2
-		},
-		GetNightlyJobStatus: func() NightlyJobStatus {
-			return NightlyJobStatus{State: "running", Running: true}
-		},
-	}
-
-	req := httptest.NewRequest(http.MethodPost, "/admin/api/tasks/stop", nil)
-	rr := httptest.NewRecorder()
-	server.handleStopAllTasks(rr, req)
-
-	if rr.Code != http.StatusAccepted {
-		t.Fatalf("status = %d, body = %s", rr.Code, rr.Body.String())
-	}
-	if !called {
-		t.Fatal("OnStopAllTasks was not called")
-	}
-	var got struct {
-		OK            bool             `json:"ok"`
-		StoppedDrives int              `json:"stoppedDrives"`
-		Status        NightlyJobStatus `json:"status"`
-	}
-	if err := json.NewDecoder(rr.Body).Decode(&got); err != nil {
-		t.Fatalf("decode: %v", err)
-	}
-	if !got.OK || got.StoppedDrives != 2 || got.Status.State != "running" || !got.Status.Running {
-		t.Fatalf("response = %#v, want stopped drives and status", got)
-	}
-}
-
 func TestHandleUpsertDrivePreservesExistingCredentialsWhenRequestCredentialsEmpty(t *testing.T) {
 	ctx := context.Background()
 	cat, err := catalog.Open(t.TempDir() + "/catalog.db")

backend/internal/api/api.go

@@ -25,7 +25,6 @@ import (
 	"github.com/video-site/backend/internal/drives/localstorage"
 	"github.com/video-site/backend/internal/drives/localupload"
 	"github.com/video-site/backend/internal/drives/spider91"
-	"github.com/video-site/backend/internal/mediaasset"
 	"github.com/video-site/backend/internal/proxy"
 )
 
@@ -861,19 +860,14 @@ func (s *Server) handlePreview(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) handleThumb(w http.ResponseWriter, r *http.Request) {
 	videoID := chi.URLParam(r, "videoID")
-	var clean string
-	for _, path := range mediaasset.ThumbnailPathCandidates(s.LocalDir, videoID) {
-		candidate := filepath.Clean(path)
-		if !strings.HasPrefix(candidate, filepath.Clean(s.LocalDir)) {
-			http.Error(w, "invalid path", http.StatusForbidden)
-			return
-		}
-		if _, err := os.Stat(candidate); err == nil {
-			clean = candidate
-			break
-		}
+	// 直接读本地 thumbs 目录中 <videoID>.jpg
+	path := filepath.Join(s.LocalDir, "thumbs", videoID+".jpg")
+	clean := filepath.Clean(path)
+	if !strings.HasPrefix(clean, filepath.Clean(s.LocalDir)) {
+		http.Error(w, "invalid path", http.StatusForbidden)
+		return
 	}
-	if clean == "" {
+	if _, err := os.Stat(clean); err != nil {
 		w.Header().Set("Cache-Control", "no-store")
 		http.NotFound(w, r)
 		return

backend/internal/api/api_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/go-chi/chi/v5"
 
 	"github.com/video-site/backend/internal/catalog"
-	"github.com/video-site/backend/internal/mediaasset"
 	"github.com/video-site/backend/internal/proxy"
 )
 
@@ -553,34 +552,6 @@ func TestHandlePreviewIgnoresRemotePreviewFileIDAndServesLocalFile(t *testing.T)
 	}
 }
 
-func TestHandleThumbServesHashedPathForLongVideoID(t *testing.T) {
-	localDir := t.TempDir()
-	longID := "localstorage-" + strings.Repeat("x", 240)
-	thumbPath := mediaasset.ThumbnailPath(localDir, longID)
-	if err := os.MkdirAll(filepath.Dir(thumbPath), 0o755); err != nil {
-		t.Fatalf("mkdir thumb dir: %v", err)
-	}
-	if err := os.WriteFile(thumbPath, []byte("thumb-bytes"), 0o644); err != nil {
-		t.Fatalf("write thumb: %v", err)
-	}
-
-	server := &Server{
-		LocalDir: localDir,
-		Proxy:    proxy.New(proxy.NewRegistry()),
-	}
-	req := requestWithRouteParam(http.MethodGet, "/p/thumb/"+longID, "videoID", longID, strings.NewReader(``))
-	rr := httptest.NewRecorder()
-
-	server.handleThumb(rr, req)
-
-	if rr.Code != http.StatusOK {
-		t.Fatalf("status = %d, body = %s", rr.Code, rr.Body.String())
-	}
-	if rr.Body.String() != "thumb-bytes" {
-		t.Fatalf("body = %q, want thumb bytes", rr.Body.String())
-	}
-}
-
 func TestHandleTagsReturnsUnifiedTagPool(t *testing.T) {
 	ctx := context.Background()
 	cat, err := catalog.Open(t.TempDir() + "/catalog.db")

backend/internal/catalog/catalog.go

@@ -5,7 +5,6 @@ import (
 	"database/sql"
 	_ "embed"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -547,7 +546,7 @@ func (c *Catalog) ListVideosByThumbnailStatus(ctx context.Context, driveID, stat
 // Besides missing thumbnails, this includes videos with an existing thumbnail but
 // missing duration metadata, because the thumbnail worker probes duration while
 // it already has a stream link.
-// Failed thumbnails are reported separately and should not block preview-video generation.
+// Failed thumbnails are reported separately and should not block teaser generation.
 // Videos whose local assets were cleared because they are fingerprint duplicates
 // stay pending in the DB, but uniqueVideoWhereSQL keeps them out of this queue
 // while their canonical sibling still exists.
@@ -708,10 +707,8 @@ func (c *Catalog) ListVideoFileIDsByDrive(ctx context.Context, driveID string) (
 func (c *Catalog) ListSpider91Viewkeys(ctx context.Context, driveID string) ([]string, error) {
 	prefix := "spider91-" + driveID + "-"
 	rows, err := c.db.QueryContext(ctx,
-		`SELECT SUBSTR(id, ?) FROM videos WHERE id LIKE ? || '%'
-		 UNION
-		 SELECT SUBSTR(id, ?) FROM deleted_videos WHERE id LIKE ? || '%'`,
-		len(prefix)+1, prefix, len(prefix)+1, prefix)
+		`SELECT SUBSTR(id, ?) FROM videos WHERE id LIKE ? || '%'`,
+		len(prefix)+1, prefix)
 	if err != nil {
 		return nil, err
 	}
@@ -729,69 +726,6 @@ func (c *Catalog) ListSpider91Viewkeys(ctx context.Context, driveID string) ([]s
 	return out, rows.Err()
 }
 
-// DeleteVideoWithTombstone records that an administrator explicitly deleted a
-// video, then removes the visible catalog row. The tombstone is used by
-// scanners/crawlers to avoid importing the same source file again.
-func (c *Catalog) DeleteVideoWithTombstone(ctx context.Context, id string) error {
-	tx, err := c.db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback()
-
-	var v struct {
-		ID          string
-		DriveID     string
-		FileID      string
-		ContentHash string
-		FileName    string
-		Size        int64
-	}
-	row := tx.QueryRowContext(ctx, `
-SELECT id, drive_id, file_id, COALESCE(content_hash, ''), COALESCE(file_name, ''), size_bytes
-  FROM videos
- WHERE id = ?`, id)
-	if err := row.Scan(&v.ID, &v.DriveID, &v.FileID, &v.ContentHash, &v.FileName, &v.Size); err != nil {
-		return err
-	}
-	v.ContentHash = normalizeContentHash(v.ContentHash)
-
-	// 先记录这次视频关联的 tag_id，便于事务末尾清理孤儿 collection 标签。
-	tagIDs, err := collectVideoTagIDs(ctx, tx, id)
-	if err != nil {
-		return err
-	}
-
-	now := time.Now().UnixMilli()
-	if _, err := tx.ExecContext(ctx, `
-INSERT INTO deleted_videos (id, drive_id, file_id, content_hash, file_name, size_bytes, deleted_at)
-VALUES (?, ?, ?, ?, ?, ?, ?)
-ON CONFLICT(id) DO UPDATE SET
-  drive_id     = excluded.drive_id,
-  file_id      = excluded.file_id,
-  content_hash = excluded.content_hash,
-  file_name    = excluded.file_name,
-  size_bytes   = excluded.size_bytes,
-  deleted_at   = excluded.deleted_at`,
-		v.ID, v.DriveID, v.FileID, v.ContentHash, v.FileName, v.Size, now); err != nil {
-		return err
-	}
-	if _, err := tx.ExecContext(ctx, `DELETE FROM video_tags WHERE video_id = ?`, id); err != nil {
-		return err
-	}
-	res, err := tx.ExecContext(ctx, `DELETE FROM videos WHERE id = ?`, id)
-	if err != nil {
-		return err
-	}
-	if rows, err := res.RowsAffected(); err == nil && rows == 0 {
-		return sql.ErrNoRows
-	}
-	if err := pruneOrphanCollectionTagsByID(ctx, tx, tagIDs); err != nil {
-		return err
-	}
-	return tx.Commit()
-}
-
 func (c *Catalog) DeleteVideo(ctx context.Context, id string) error {
 	tx, err := c.db.BeginTx(ctx, nil)
 	if err != nil {
@@ -825,55 +759,6 @@ func (c *Catalog) DeleteVideo(ctx context.Context, id string) error {
 	return tx.Commit()
 }
 
-func (c *Catalog) IsVideoDeleted(ctx context.Context, id string) (bool, error) {
-	id = strings.TrimSpace(id)
-	if id == "" {
-		return false, nil
-	}
-	var found int
-	err := c.db.QueryRowContext(ctx, `SELECT 1 FROM deleted_videos WHERE id = ? LIMIT 1`, id).Scan(&found)
-	if errors.Is(err, sql.ErrNoRows) {
-		return false, nil
-	}
-	if err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (c *Catalog) IsDeletedVideoCandidate(ctx context.Context, id, driveID, fileID, contentHash, fileName string, size int64) (bool, error) {
-	id = strings.TrimSpace(id)
-	driveID = strings.TrimSpace(driveID)
-	fileID = strings.TrimSpace(fileID)
-	contentHash = normalizeContentHash(contentHash)
-	fileName = strings.TrimSpace(fileName)
-	if id == "" && driveID == "" {
-		return false, nil
-	}
-
-	var found int
-	err := c.db.QueryRowContext(ctx, `
-SELECT 1
-  FROM deleted_videos
- WHERE id = ?
-    OR (drive_id = ? AND ? != '' AND file_id = ?)
-    OR (drive_id = ? AND ? != '' AND content_hash = ?)
-    OR (drive_id = ? AND ? != '' AND ? > 0 AND file_name = ? AND size_bytes = ?)
- LIMIT 1`,
-		id,
-		driveID, fileID, fileID,
-		driveID, contentHash, contentHash,
-		driveID, fileName, size, fileName, size,
-	).Scan(&found)
-	if errors.Is(err, sql.ErrNoRows) {
-		return false, nil
-	}
-	if err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
 func (c *Catalog) FindVideoByContentHash(ctx context.Context, hash string) (*Video, error) {
 	hash = normalizeContentHash(hash)
 	if hash == "" {
@@ -1487,7 +1372,7 @@ func (c *Catalog) ListLocalMediaRefs(ctx context.Context) ([]LocalMediaRef, erro
 
 // DuplicateAssetCleanupCandidate points at a non-canonical video in a
 // size+sampled_sha256 duplicate group that still owns generated local assets.
-// The cleanup job uses this to remove duplicate thumbnails/preview videos without
+// The cleanup job uses this to remove duplicate thumbnails/teasers without
 // touching the original cloud file or deleting the catalog row.
 type DuplicateAssetCleanupCandidate struct {
 	VideoID       string
@@ -1615,7 +1500,7 @@ type Drive struct {
 	Credentials map[string]string `json:"credentials,omitempty"`
 	Status      string            `json:"status"`
 	LastError   string            `json:"lastError,omitempty"`
-	// TeaserEnabled 控制是否给本盘生成预览视频/封面。
+	// TeaserEnabled 控制是否给本盘生成 teaser/封面。
 	// 替代早期的全局 preview.enabled 开关；新建 drive 时 UpsertDrive 默认置 true。
 	TeaserEnabled bool `json:"teaserEnabled"`
 	// SkipDirIDs 是用户在管理后台为该盘选定的"扫描跳过目录"集合（网盘侧的目录 fileID）。
@@ -1748,7 +1633,7 @@ func (c *Catalog) DeleteDrive(ctx context.Context, id string) error {
 	return err
 }
 
-// SetDriveTeaserEnabled 切换某盘的预览视频/封面生成开关。
+// SetDriveTeaserEnabled 切换某盘的 teaser/封面生成开关。
 //
 // 与 UpsertDrive 的区别：只动 teaser_enabled + updated_at 一列，不要求调用方
 // 重传 kind / name / credentials 等容易踩坑的字段。

backend/internal/catalog/file_ids_test.go

@@ -2,7 +2,6 @@ package catalog
 
 import (
 	"context"
-	"database/sql"
 	"sort"
 	"testing"
 	"time"
@@ -127,50 +126,3 @@ func TestListSpider91ViewkeysFindsMigratedVideos(t *testing.T) {
 		t.Fatalf("non-existent drive: got %v, want empty", other)
 	}
 }
-
-func TestDeleteVideoWithTombstonePreventsReimport(t *testing.T) {
-	ctx := context.Background()
-	cat, err := Open(t.TempDir() + "/catalog.db")
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() { _ = cat.Close() })
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &Video{
-		ID:            "spider91-91Spider-vk004",
-		DriveID:       "91Spider",
-		FileID:        "vk004.mp4",
-		FileName:      "vk004.mp4",
-		ContentHash:   "ABCDEF",
-		Title:         "Deleted Spider",
-		Size:          2048,
-		PreviewStatus: "ready",
-		PublishedAt:   now,
-		CreatedAt:     now,
-		UpdatedAt:     now,
-	}); err != nil {
-		t.Fatalf("upsert: %v", err)
-	}
-
-	if err := cat.DeleteVideoWithTombstone(ctx, "spider91-91Spider-vk004"); err != nil {
-		t.Fatalf("delete with tombstone: %v", err)
-	}
-	if _, err := cat.GetVideo(ctx, "spider91-91Spider-vk004"); err != sql.ErrNoRows {
-		t.Fatalf("get deleted video error = %v, want sql.ErrNoRows", err)
-	}
-	deleted, err := cat.IsDeletedVideoCandidate(ctx, "spider91-91Spider-vk004", "91Spider", "vk004.mp4", "abcdef", "vk004.mp4", 2048)
-	if err != nil {
-		t.Fatalf("check deleted candidate: %v", err)
-	}
-	if !deleted {
-		t.Fatal("deleted candidate was not recognized")
-	}
-	viewkeys, err := cat.ListSpider91Viewkeys(ctx, "91Spider")
-	if err != nil {
-		t.Fatalf("ListSpider91Viewkeys: %v", err)
-	}
-	if len(viewkeys) != 1 || viewkeys[0] != "vk004" {
-		t.Fatalf("viewkeys = %#v, want [vk004]", viewkeys)
-	}
-}

backend/internal/catalog/schema.sql

@@ -19,8 +19,8 @@ CREATE TABLE IF NOT EXISTS videos (
     thumbnail_url    TEXT,
     thumbnail_status TEXT DEFAULT 'pending',    -- pending / ready / failed / skipped
     thumbnail_failures INTEGER DEFAULT 0,        -- consecutive transient thumbnail generation failures
-    preview_file_id  TEXT,                      -- deprecated: 旧版回写网盘后的预览视频 file id
-    preview_local    TEXT,                      -- 本地预览视频路径（兜底）
+    preview_file_id  TEXT,                      -- deprecated: 旧版回写网盘后的 teaser file id
+    preview_local    TEXT,                      -- 本地 teaser 路径（兜底）
     preview_status   TEXT DEFAULT 'pending',    -- pending / ready / failed
     views            INTEGER DEFAULT 0,
     favorites        INTEGER DEFAULT 0,
@@ -70,25 +70,6 @@ CREATE TABLE IF NOT EXISTS deleted_tags (
     deleted_at INTEGER NOT NULL
 );
 
--- 管理员显式删除过的视频。用于防止后续扫描 / spider91 爬虫把同一个源文件
--- 再次入库；不代表原始云盘文件已被删除。
-CREATE TABLE IF NOT EXISTS deleted_videos (
-    id           TEXT PRIMARY KEY,
-    drive_id     TEXT NOT NULL DEFAULT '',
-    file_id      TEXT NOT NULL DEFAULT '',
-    content_hash TEXT NOT NULL DEFAULT '',
-    file_name    TEXT NOT NULL DEFAULT '',
-    size_bytes   INTEGER NOT NULL DEFAULT 0,
-    deleted_at   INTEGER NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_file
-    ON deleted_videos(drive_id, file_id);
-CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_hash
-    ON deleted_videos(drive_id, content_hash);
-CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_signature
-    ON deleted_videos(drive_id, file_name, size_bytes);
-
 -- 网盘账户
 CREATE TABLE IF NOT EXISTS drives (
     id            TEXT PRIMARY KEY,
@@ -99,7 +80,7 @@ CREATE TABLE IF NOT EXISTS drives (
     credentials   TEXT,                          -- JSON: cookie / refresh_token 等
     status        TEXT DEFAULT 'disconnected',   -- disconnected / ok / error
     last_error    TEXT,
-    -- 是否给该盘生成预览视频/封面：1 开 / 0 关。
+    -- 是否给该盘生成 teaser/封面：1 开 / 0 关。
     -- 替代了早期的全局 preview.enabled 设置（保留旧 setting 行不再读）。
     teaser_enabled INTEGER NOT NULL DEFAULT 1,
     -- 扫描时要跳过的目录 ID 集合（JSON array of string）。命中其中任意一个的目录及其

backend/internal/catalog/tags.go

@@ -66,10 +66,10 @@ func (c *Catalog) migrate(ctx context.Context) error {
 	if err := c.addColumnIfMissing(ctx, "videos", "thumbnail_failures", "INTEGER DEFAULT 0"); err != nil {
 		return err
 	}
-	// drives.teaser_enabled：每盘预览视频开关，替代旧的全局 preview.enabled。
+	// drives.teaser_enabled：每盘 teaser 开关，替代旧的全局 preview.enabled。
 	// 升级路径：直接让 ALTER TABLE 的 DEFAULT 1 兜底 —— 每个现存 drive 都默认开启，
 	// 不读旧的 settings.preview.enabled 字段。这样老用户即便之前关过全局开关，
-	// 升级后所有盘也都恢复"默认生成预览视频"，跟新建保持一致。
+	// 升级后所有盘也都恢复"默认生成 teaser"，跟新建保持一致。
 	if _, err := c.addColumnIfMissingReportNew(ctx, "drives", "teaser_enabled", "INTEGER NOT NULL DEFAULT 1"); err != nil {
 		return err
 	}
@@ -79,18 +79,6 @@ func (c *Catalog) migrate(ctx context.Context) error {
 	if err := c.addColumnIfMissing(ctx, "drives", "skip_dir_ids", "TEXT NOT NULL DEFAULT '[]'"); err != nil {
 		return err
 	}
-	if _, err := c.db.ExecContext(ctx, `
-CREATE TABLE IF NOT EXISTS deleted_videos (
-	id           TEXT PRIMARY KEY,
-	drive_id     TEXT NOT NULL DEFAULT '',
-	file_id      TEXT NOT NULL DEFAULT '',
-	content_hash TEXT NOT NULL DEFAULT '',
-	file_name    TEXT NOT NULL DEFAULT '',
-	size_bytes   INTEGER NOT NULL DEFAULT 0,
-	deleted_at   INTEGER NOT NULL
-)`); err != nil {
-		return err
-	}
 	if err := c.syncDriveScanRootIDToRootID(ctx); err != nil {
 		return err
 	}
@@ -133,15 +121,6 @@ CREATE TABLE IF NOT EXISTS deleted_videos (
 	if _, err := c.db.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_videos_file_name_size_created ON videos(file_name, size_bytes, created_at, id)`); err != nil {
 		return err
 	}
-	if _, err := c.db.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_file ON deleted_videos(drive_id, file_id)`); err != nil {
-		return err
-	}
-	if _, err := c.db.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_hash ON deleted_videos(drive_id, content_hash)`); err != nil {
-		return err
-	}
-	if _, err := c.db.ExecContext(ctx, `CREATE INDEX IF NOT EXISTS idx_deleted_videos_drive_signature ON deleted_videos(drive_id, file_name, size_bytes)`); err != nil {
-		return err
-	}
 	if err := c.seedSystemTags(ctx); err != nil {
 		return err
 	}
@@ -214,7 +193,7 @@ func (c *Catalog) addColumnIfMissingReportNew(ctx context.Context, table, column
 // 设为 1（开启），但仅在历史上没跑过这条迁移时执行（用 marker setting 记号）。
 //
 // 为什么需要：早期短暂存在过的版本会从旧的全局 preview.enabled = "0" 同步到
-// 所有 drive 的 teaser_enabled = 0；用户报告升级后页面全显示"预览视频关"。新版
+// 所有 drive 的 teaser_enabled = 0；用户报告升级后页面全显示"Teaser 关"。新版
 // 约定 per-drive 默认开启，所以这里跑一次性修正。
 //
 // 幂等保证：marker setting 设过了就不再跑，确保用户在 UI 里把某盘关了不会被

backend/internal/drives/iface.go

@@ -30,7 +30,7 @@ type Drive interface {
 	StreamURL(ctx context.Context, fileID string) (*StreamLink, error)
 
 	// Upload 把本地流写入指定目录，返回新文件 fileID。
-	// 当前预览视频和封面只保存在本地，不再通过该方法写回网盘。
+	// 当前 teaser 和封面只保存在本地，不再通过该方法写回网盘。
 	Upload(ctx context.Context, parentID, name string, r io.Reader, size int64) (string, error)
 
 	// EnsureDir 保证指定路径存在（相对根目录），返回最终目录 fileID。

backend/internal/drives/p115/driver.go

@@ -149,10 +149,6 @@ func sleepContext(ctx context.Context, d time.Duration) error {
 }
 
 func isTransient115ListError(err error) bool {
-	return isTransient115UpstreamError(err)
-}
-
-func isTransient115UpstreamError(err error) bool {
 	if err == nil {
 		return false
 	}
@@ -252,11 +248,11 @@ func (d *Driver) streamURLWithUA(ctx context.Context, fileID string, ua string)
 	// 需要先拿到 pickCode
 	f, err := d.client.GetFile(fileID)
 	if err != nil {
-		return nil, wrap115StreamTransientError("115 get file", err)
+		return nil, fmt.Errorf("115 get file: %w", err)
 	}
 	info, ua, err := d.downloadInfo(f.PickCode, ua)
 	if err != nil {
-		return nil, wrap115StreamTransientError("115 download url", err)
+		return nil, fmt.Errorf("115 download url: %w", err)
 	}
 	if info == nil || info.Url.Url == "" {
 		return nil, errors.New("115 download url: empty")
@@ -292,18 +288,6 @@ func (d *Driver) downloadInfo(pickCode string, ua string) (*sdk.DownloadInfo, st
 	return info, ua, nil
 }
 
-func wrap115StreamTransientError(op string, err error) error {
-	wrapped := fmt.Errorf("%s: %w", op, err)
-	if !isTransient115UpstreamError(err) {
-		return wrapped
-	}
-	return &drives.RateLimitError{
-		Provider:   "p115",
-		RetryAfter: p115ListCooldown,
-		Err:        wrapped,
-	}
-}
-
 func (d *Driver) Upload(ctx context.Context, parentID, name string, r io.Reader, size int64) (string, error) {
 	res, err := d.UploadAndReportSha1(ctx, parentID, name, r, size)
 	if err != nil {

backend/internal/drives/p115/driver_test.go

@@ -10,9 +10,6 @@ import (
 	"os"
 	"strings"
 	"testing"
-	"time"
-
-	"github.com/video-site/backend/internal/drives"
 )
 
 func TestIsTransient115ListError(t *testing.T) {
@@ -37,42 +34,6 @@ func TestIsTransient115ListError(t *testing.T) {
 	}
 }
 
-func TestWrap115StreamTransientError(t *testing.T) {
-	cases := []struct {
-		name          string
-		err           error
-		wantRateLimit bool
-	}{
-		{name: "unexpected", err: errors.New("unexpected error"), wantRateLimit: true},
-		{name: "405 blocked", err: errors.New("405 request has been blocked"), wantRateLimit: true},
-		{name: "429", err: errors.New("429 too many requests"), wantRateLimit: true},
-		{name: "blocked", err: errors.New("blocked by waf"), wantRateLimit: true},
-		{name: "auth", err: errors.New("invalid credential"), wantRateLimit: false},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := wrap115StreamTransientError("115 get file", tc.err)
-			var rateLimit *drives.RateLimitError
-			isRateLimit := errors.As(got, &rateLimit)
-			if isRateLimit != tc.wantRateLimit {
-				t.Fatalf("rate limit = %v, want %v; err=%v", isRateLimit, tc.wantRateLimit, got)
-			}
-			if !strings.Contains(got.Error(), "115 get file") {
-				t.Fatalf("err = %v, want operation prefix", got)
-			}
-			if tc.wantRateLimit {
-				if rateLimit.Provider != "p115" {
-					t.Fatalf("provider = %q, want p115", rateLimit.Provider)
-				}
-				if rateLimit.RetryAfter != 10*time.Minute {
-					t.Fatalf("retry after = %s, want 10m", rateLimit.RetryAfter)
-				}
-			}
-		})
-	}
-}
-
 // TestBufferAndHashSha1 验证 bufferAndHashSha1：
 //
 //   - 把 reader 的全部字节落到 tmp 文件

backend/internal/drives/p123/driver.go

@@ -2,9 +2,7 @@ package p123
 
 import (
 	"context"
-	"crypto/md5"
 	"encoding/base64"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -15,7 +13,6 @@ import (
 	"math/rand"
 	"net/http"
 	"net/url"
-	"os"
 	"path"
 	"strconv"
 	"strings"
@@ -41,16 +38,9 @@ const (
 	endpointFileList     = "/file/list/new"
 	endpointDownloadInfo = "/file/download_info"
 	endpointMkdir        = "/file/upload_request"
-	endpointRename       = "/file/rename"
-	endpointUpload       = "/file/upload_request"
-	endpointS3Auth       = "/file/s3_upload_object/auth"
-	endpointS3Parts      = "/file/s3_repare_upload_parts_batch"
-	endpointUploadDone   = "/file/upload_complete/v2"
 
 	listInterval = 700 * time.Millisecond
 	listCooldown = 10 * time.Minute
-
-	uploadChunkSize = int64(16 * 1024 * 1024)
 )
 
 type Driver struct {
@@ -247,302 +237,8 @@ func (d *Driver) StreamURL(ctx context.Context, fileID string) (*drives.StreamLi
 	return d.resolveDownloadURL(ctx, downloadURL)
 }
 
-// Upload 实现 drives.Drive 接口；只返回 fileID。
-// 完整上传元数据见 UploadAndReportHash。
-func (d *Driver) Upload(ctx context.Context, parentID, name string, r io.Reader, size int64) (string, error) {
-	res, err := d.UploadAndReportHash(ctx, parentID, name, r, size)
-	if err != nil {
-		return "", err
-	}
-	return res.FileID, nil
-}
-
-// UploadResult 是 UploadAndReportHash 的返回值。
-//
-// FileID 是 123 云盘分配的新文件 ID；Hash 是本次上传的 MD5 HEX（小写），
-// 与 123 云盘列表返回的 Etag 一致；Size 是实际上传字节数。
-type UploadResult struct {
-	FileID string
-	Hash   string
-	Size   int64
-}
-
-// UploadAndReportHash 把 r 上传到 parentID 目录下的指定文件名，返回新文件元数据。
-//
-// 123 云盘 Web 上传协议需要先计算文件 MD5 作为 etag 申请 upload_request。
-// 命中 Reuse 时服务端已经秒传；否则用返回的 S3 预签名 URL 分片 PUT，最后
-// 调 upload_complete/v2 完成。
-func (d *Driver) UploadAndReportHash(ctx context.Context, parentID, name string, r io.Reader, size int64) (UploadResult, error) {
-	if r == nil {
-		return UploadResult{}, errors.New("123pan upload: nil reader")
-	}
-	if size < 0 {
-		return UploadResult{}, fmt.Errorf("123pan upload: invalid size %d", size)
-	}
-	name = strings.TrimSpace(name)
-	if name == "" {
-		return UploadResult{}, errors.New("123pan upload: empty file name")
-	}
-	parentID = strings.TrimSpace(parentID)
-	if parentID == "" || parentID == "/" {
-		parentID = d.rootID
-	}
-
-	tmp, md5Hex, actualSize, err := bufferAndHashMD5(r, size)
-	if err != nil {
-		return UploadResult{}, err
-	}
-	defer func() {
-		_ = tmp.Close()
-		_ = os.Remove(tmp.Name())
-	}()
-
-	body := map[string]any{
-		"driveId":      0,
-		"duplicate":    2,
-		"etag":         md5Hex,
-		"fileName":     name,
-		"parentFileId": parentID,
-		"size":         actualSize,
-		"type":         0,
-	}
-	var resp uploadResp
-	if _, err := d.request(ctx, endpointUpload, http.MethodPost, func(req *resty.Request) {
-		req.SetBody(body)
-	}, &resp); err != nil {
-		return UploadResult{}, fmt.Errorf("123pan upload: request session: %w", err)
-	}
-
-	result := UploadResult{
-		FileID: strconv.FormatInt(resp.Data.FileID, 10),
-		Hash:   md5Hex,
-		Size:   actualSize,
-	}
-	if resp.Data.FileID == 0 {
-		result.FileID = ""
-	}
-
-	if resp.Data.Reuse || strings.TrimSpace(resp.Data.Key) == "" {
-		if result.FileID == "" {
-			fileID, err := d.findUploadedFileID(ctx, parentID, name, md5Hex)
-			if err != nil {
-				return UploadResult{}, err
-			}
-			result.FileID = fileID
-		}
-		d.cacheUploadedFile(result.FileID, parentID, name, md5Hex, actualSize)
-		return result, nil
-	}
-
-	if err := d.uploadToPresignedURLs(ctx, &resp, tmp, actualSize); err != nil {
-		return UploadResult{}, err
-	}
-	if err := d.completeUpload(ctx, &resp, actualSize); err != nil {
-		return UploadResult{}, err
-	}
-	if result.FileID == "" {
-		fileID, err := d.findUploadedFileID(ctx, parentID, name, md5Hex)
-		if err != nil {
-			return UploadResult{}, err
-		}
-		result.FileID = fileID
-	}
-	d.cacheUploadedFile(result.FileID, parentID, name, md5Hex, actualSize)
-	return result, nil
-}
-
-func (d *Driver) uploadToPresignedURLs(ctx context.Context, up *uploadResp, tmp *os.File, size int64) error {
-	if strings.TrimSpace(up.Data.Bucket) == "" || strings.TrimSpace(up.Data.Key) == "" || strings.TrimSpace(up.Data.UploadID) == "" {
-		return errors.New("123pan upload: incomplete upload session")
-	}
-	chunkCount := int64(1)
-	if size > uploadChunkSize {
-		chunkCount = (size + uploadChunkSize - 1) / uploadChunkSize
-	}
-	batchSize := int64(1)
-	endpoint := endpointS3Auth
-	if chunkCount > 1 {
-		batchSize = 10
-		endpoint = endpointS3Parts
-	}
-	for start := int64(1); start <= chunkCount; start += batchSize {
-		end := minInt64(start+batchSize, chunkCount+1)
-		urls, err := d.getUploadURLs(ctx, endpoint, up, start, end)
-		if err != nil {
-			return err
-		}
-		for part := start; part < end; part++ {
-			offset := (part - 1) * uploadChunkSize
-			partSize := minInt64(uploadChunkSize, size-offset)
-			uploadURL := strings.TrimSpace(urls.Data.PreSignedURLs[strconv.FormatInt(part, 10)])
-			if uploadURL == "" {
-				return fmt.Errorf("123pan upload: empty presigned url for part %d", part)
-			}
-			if err := d.putUploadPart(ctx, uploadURL, tmp, offset, partSize); err != nil {
-				if !isForbiddenUploadPart(err) {
-					return err
-				}
-				refreshed, refreshErr := d.getUploadURLs(ctx, endpoint, up, part, part+1)
-				if refreshErr != nil {
-					return refreshErr
-				}
-				uploadURL = strings.TrimSpace(refreshed.Data.PreSignedURLs[strconv.FormatInt(part, 10)])
-				if uploadURL == "" {
-					return fmt.Errorf("123pan upload: empty refreshed presigned url for part %d", part)
-				}
-				if retryErr := d.putUploadPart(ctx, uploadURL, tmp, offset, partSize); retryErr != nil {
-					return retryErr
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func (d *Driver) getUploadURLs(ctx context.Context, endpoint string, up *uploadResp, start, end int64) (*s3PreSignedURLsResp, error) {
-	body := map[string]any{
-		"StorageNode":     up.Data.StorageNode,
-		"bucket":          up.Data.Bucket,
-		"key":             up.Data.Key,
-		"partNumberEnd":   end,
-		"partNumberStart": start,
-		"uploadId":        up.Data.UploadID,
-	}
-	var resp s3PreSignedURLsResp
-	if _, err := d.request(ctx, endpoint, http.MethodPost, func(req *resty.Request) {
-		req.SetBody(body)
-	}, &resp); err != nil {
-		return nil, fmt.Errorf("123pan upload: presigned urls: %w", err)
-	}
-	return &resp, nil
-}
-
-type forbiddenUploadPartError struct {
-	status int
-}
-
-func (e *forbiddenUploadPartError) Error() string {
-	return fmt.Sprintf("123pan upload: presigned put status=%d", e.status)
-}
-
-func isForbiddenUploadPart(err error) bool {
-	var forbidden *forbiddenUploadPartError
-	return errors.As(err, &forbidden)
-}
-
-func (d *Driver) putUploadPart(ctx context.Context, uploadURL string, tmp *os.File, offset, size int64) error {
-	reader := io.NewSectionReader(tmp, offset, size)
-	req, err := http.NewRequestWithContext(ctx, http.MethodPut, uploadURL, reader)
-	if err != nil {
-		return err
-	}
-	req.ContentLength = size
-	req.Header.Set("User-Agent", d.userAgent)
-	res, err := d.httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("123pan upload: presigned put: %w", err)
-	}
-	defer res.Body.Close()
-	if res.StatusCode == http.StatusOK || res.StatusCode == http.StatusCreated || res.StatusCode == http.StatusNoContent {
-		return nil
-	}
-	body, _ := io.ReadAll(io.LimitReader(res.Body, 4096))
-	if isP123RateLimitHTTPResponse(res.StatusCode, res.Header.Get("Retry-After"), string(body)) {
-		return p123RateLimitErrorFromHTTP("upload part", res.StatusCode, res.Header.Get("Retry-After"), string(body))
-	}
-	if res.StatusCode == http.StatusForbidden {
-		return &forbiddenUploadPartError{status: res.StatusCode}
-	}
-	return fmt.Errorf("123pan upload: presigned put status=%d body=%s", res.StatusCode, strings.TrimSpace(string(body)))
-}
-
-func (d *Driver) completeUpload(ctx context.Context, up *uploadResp, size int64) error {
-	if up.Data.FileID == 0 {
-		return errors.New("123pan upload: empty file id")
-	}
-	body := map[string]any{
-		"StorageNode": up.Data.StorageNode,
-		"bucket":      up.Data.Bucket,
-		"fileId":      up.Data.FileID,
-		"fileSize":    size,
-		"isMultipart": size > uploadChunkSize,
-		"key":         up.Data.Key,
-		"uploadId":    up.Data.UploadID,
-	}
-	if _, err := d.request(ctx, endpointUploadDone, http.MethodPost, func(req *resty.Request) {
-		req.SetBody(body)
-	}, nil); err != nil {
-		return fmt.Errorf("123pan upload: complete: %w", err)
-	}
-	return nil
-}
-
-func (d *Driver) findUploadedFileID(ctx context.Context, parentID, name, md5Hex string) (string, error) {
-	entries, err := d.List(ctx, parentID)
-	if err != nil {
-		return "", fmt.Errorf("123pan upload verify: %w", err)
-	}
-	var hashHit string
-	for _, e := range entries {
-		if e.IsDir {
-			continue
-		}
-		if !strings.EqualFold(e.Hash, md5Hex) {
-			continue
-		}
-		if e.Name == name {
-			return e.ID, nil
-		}
-		if hashHit == "" {
-			hashHit = e.ID
-		}
-	}
-	if hashHit != "" {
-		return hashHit, nil
-	}
-	for _, e := range entries {
-		if !e.IsDir && e.Name == name {
-			return e.ID, nil
-		}
-	}
-	return "", fmt.Errorf("123pan upload: uploaded file %q not found in parent %q", name, parentID)
-}
-
-func (d *Driver) cacheUploadedFile(fileID, parentID, name, md5Hex string, size int64) {
-	id, err := strconv.ParseInt(strings.TrimSpace(fileID), 10, 64)
-	if err != nil || id == 0 {
-		return
-	}
-	d.cacheFile(panFile{
-		FileName: name,
-		Size:     size,
-		FileID:   id,
-		Type:     0,
-		Etag:     md5Hex,
-	}, parentID)
-}
-
-// Rename 调用 123 云盘 Web API 把指定 fileID 重命名为 newName。
-func (d *Driver) Rename(ctx context.Context, fileID, newName string) error {
-	fileID = strings.TrimSpace(fileID)
-	if fileID == "" {
-		return errors.New("123pan rename: empty file id")
-	}
-	newName = strings.TrimSpace(newName)
-	if newName == "" {
-		return errors.New("123pan rename: empty new name")
-	}
-	if _, err := d.request(ctx, endpointRename, http.MethodPost, func(req *resty.Request) {
-		req.SetBody(map[string]any{
-			"driveId":  0,
-			"fileId":   fileID,
-			"fileName": newName,
-		})
-	}, nil); err != nil {
-		return fmt.Errorf("123pan rename: %w", err)
-	}
-	d.renameCachedFile(fileID, newName)
-	return nil
+func (d *Driver) Upload(context.Context, string, string, io.Reader, int64) (string, error) {
+	return "", drives.ErrNotSupported
 }
 
 func (d *Driver) EnsureDir(ctx context.Context, pathFromRoot string) (string, error) {
@@ -933,15 +629,6 @@ func (d *Driver) cacheFile(f panFile, parentID string) {
 	d.fileMu.Unlock()
 }
 
-func (d *Driver) renameCachedFile(fileID, newName string) {
-	d.fileMu.Lock()
-	defer d.fileMu.Unlock()
-	if c, ok := d.files[fileID]; ok {
-		c.file.FileName = newName
-		d.files[fileID] = c
-	}
-}
-
 func (d *Driver) cachedFile(fileID string) (panFile, string, bool) {
 	d.fileMu.RLock()
 	defer d.fileMu.RUnlock()
@@ -1051,33 +738,6 @@ func splitPath(p string) []string {
 	return strings.Split(p, "/")
 }
 
-func bufferAndHashMD5(r io.Reader, declaredSize int64) (*os.File, string, int64, error) {
-	tmp, err := os.CreateTemp("", "p123-upload-*.bin")
-	if err != nil {
-		return nil, "", 0, fmt.Errorf("123pan upload: create tmp: %w", err)
-	}
-	h := md5.New()
-	written, err := io.Copy(io.MultiWriter(tmp, h), r)
-	if err != nil {
-		_ = tmp.Close()
-		_ = os.Remove(tmp.Name())
-		return nil, "", 0, fmt.Errorf("123pan upload: buffer body: %w", err)
-	}
-	if declaredSize >= 0 && written != declaredSize {
-		_ = tmp.Close()
-		_ = os.Remove(tmp.Name())
-		return nil, "", 0, fmt.Errorf("123pan upload: size mismatch: declared %d, copied %d", declaredSize, written)
-	}
-	return tmp, strings.ToLower(hex.EncodeToString(h.Sum(nil))), written, nil
-}
-
-func minInt64(a, b int64) int64 {
-	if a < b {
-		return a
-	}
-	return b
-}
-
 func fileToEntry(f panFile, parentID string) drives.Entry {
 	return drives.Entry{
 		ID:       strconv.FormatInt(f.FileID, 10),

backend/internal/drives/p123/driver_test.go

@@ -1,14 +1,10 @@
 package p123
 
 import (
-	"bytes"
 	"context"
-	"crypto/md5"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
-	"fmt"
-	"io"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -258,230 +254,3 @@ func TestResolveDownloadURL429ReturnsRateLimitError(t *testing.T) {
 		t.Fatalf("RetryAfter = %s, want 3s", rateLimit.RetryAfter)
 	}
 }
-
-func TestUploadAndReportHashUsesPresignedPUTAndComplete(t *testing.T) {
-	ctx := context.Background()
-	body := []byte("video bytes for 123 upload")
-	wantMD5 := fmt.Sprintf("%x", md5.Sum(body))
-
-	var putBody []byte
-	upload := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPut {
-			t.Fatalf("upload method = %s, want PUT", r.Method)
-		}
-		if r.ContentLength != int64(len(body)) {
-			t.Fatalf("ContentLength = %d, want %d", r.ContentLength, len(body))
-		}
-		got, err := io.ReadAll(r.Body)
-		if err != nil {
-			t.Fatalf("read upload body: %v", err)
-		}
-		putBody = got
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer upload.Close()
-
-	var uploadRequest map[string]any
-	var uploadURLRequest map[string]any
-	var completeRequest map[string]any
-	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch r.URL.Path {
-		case "/file/upload_request":
-			if err := json.NewDecoder(r.Body).Decode(&uploadRequest); err != nil {
-				t.Fatalf("decode upload_request: %v", err)
-			}
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"code": 0,
-				"data": map[string]any{
-					"FileId":      9001,
-					"Bucket":      "bucket-1",
-					"Key":         "key-1",
-					"StorageNode": "node-1",
-					"UploadId":    "upload-1",
-				},
-			})
-		case "/file/s3_upload_object/auth":
-			if err := json.NewDecoder(r.Body).Decode(&uploadURLRequest); err != nil {
-				t.Fatalf("decode s3 auth: %v", err)
-			}
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"code": 0,
-				"data": map[string]any{
-					"presignedUrls": map[string]string{
-						"1": upload.URL + "/part-1",
-					},
-				},
-			})
-		case "/file/upload_complete/v2":
-			if err := json.NewDecoder(r.Body).Decode(&completeRequest); err != nil {
-				t.Fatalf("decode complete: %v", err)
-			}
-			_ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{}})
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer api.Close()
-
-	d := New(Config{
-		ID:             "123-main",
-		AccessToken:    "token-1",
-		MainAPIBaseURL: api.URL,
-	})
-	res, err := d.UploadAndReportHash(ctx, "parent-1", "video.mp4", bytes.NewReader(body), int64(len(body)))
-	if err != nil {
-		t.Fatalf("UploadAndReportHash() error = %v", err)
-	}
-	if res.FileID != "9001" {
-		t.Fatalf("FileID = %q, want 9001", res.FileID)
-	}
-	if res.Hash != wantMD5 {
-		t.Fatalf("Hash = %q, want %q", res.Hash, wantMD5)
-	}
-	if res.Size != int64(len(body)) {
-		t.Fatalf("Size = %d, want %d", res.Size, len(body))
-	}
-	if !bytes.Equal(putBody, body) {
-		t.Fatalf("PUT body = %q, want %q", putBody, body)
-	}
-	if uploadRequest["etag"] != wantMD5 {
-		t.Fatalf("upload etag = %#v, want %q", uploadRequest["etag"], wantMD5)
-	}
-	if uploadRequest["fileName"] != "video.mp4" || uploadRequest["parentFileId"] != "parent-1" {
-		t.Fatalf("upload request = %#v, want fileName and parentFileId", uploadRequest)
-	}
-	if uploadURLRequest["partNumberStart"].(float64) != 1 || uploadURLRequest["partNumberEnd"].(float64) != 2 {
-		t.Fatalf("s3 auth request = %#v, want part range 1..2", uploadURLRequest)
-	}
-	if completeRequest["fileId"].(float64) != 9001 || completeRequest["fileSize"].(float64) != float64(len(body)) {
-		t.Fatalf("complete request = %#v, want file id and size", completeRequest)
-	}
-	if completeRequest["isMultipart"].(bool) {
-		t.Fatalf("complete isMultipart = true, want false")
-	}
-}
-
-func TestUploadAndReportHashReuseSkipsPUTAndComplete(t *testing.T) {
-	body := []byte("reused body")
-	var presignedCalled bool
-	var completeCalled bool
-	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch r.URL.Path {
-		case "/file/upload_request":
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"code": 0,
-				"data": map[string]any{
-					"FileId": 7001,
-					"Reuse":  true,
-				},
-			})
-		case "/file/s3_upload_object/auth", "/file/s3_repare_upload_parts_batch":
-			presignedCalled = true
-			_ = json.NewEncoder(w).Encode(map[string]any{"code": 0})
-		case "/file/upload_complete/v2":
-			completeCalled = true
-			_ = json.NewEncoder(w).Encode(map[string]any{"code": 0})
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer api.Close()
-
-	d := New(Config{
-		ID:             "123-main",
-		AccessToken:    "token-1",
-		MainAPIBaseURL: api.URL,
-	})
-	res, err := d.UploadAndReportHash(context.Background(), "parent-1", "reused.mp4", bytes.NewReader(body), int64(len(body)))
-	if err != nil {
-		t.Fatalf("UploadAndReportHash() error = %v", err)
-	}
-	if res.FileID != "7001" {
-		t.Fatalf("FileID = %q, want 7001", res.FileID)
-	}
-	if presignedCalled {
-		t.Fatal("reuse upload should not request presigned URLs")
-	}
-	if completeCalled {
-		t.Fatal("reuse upload should not call upload_complete")
-	}
-}
-
-func TestUploadPresignedPUT429ReturnsRateLimitError(t *testing.T) {
-	upload := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Retry-After", "4")
-		http.Error(w, "too many requests", http.StatusTooManyRequests)
-	}))
-	defer upload.Close()
-
-	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch r.URL.Path {
-		case "/file/upload_request":
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"code": 0,
-				"data": map[string]any{
-					"FileId":      9001,
-					"Bucket":      "bucket-1",
-					"Key":         "key-1",
-					"StorageNode": "node-1",
-					"UploadId":    "upload-1",
-				},
-			})
-		case "/file/s3_upload_object/auth":
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"code": 0,
-				"data": map[string]any{
-					"presignedUrls": map[string]string{"1": upload.URL},
-				},
-			})
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer api.Close()
-
-	d := New(Config{
-		ID:             "123-main",
-		AccessToken:    "token-1",
-		MainAPIBaseURL: api.URL,
-	})
-	_, err := d.UploadAndReportHash(context.Background(), "parent-1", "limited.mp4", strings.NewReader("limited"), int64(len("limited")))
-	var rateLimit *drives.RateLimitError
-	if !errors.As(err, &rateLimit) {
-		t.Fatalf("error = %T %[1]v, want RateLimitError", err)
-	}
-	if rateLimit.RetryAfter != 4*time.Second {
-		t.Fatalf("RetryAfter = %s, want 4s", rateLimit.RetryAfter)
-	}
-}
-
-func TestRenameSendsExpectedBody(t *testing.T) {
-	var renameRequest map[string]any
-	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		if r.URL.Path != "/file/rename" {
-			http.NotFound(w, r)
-			return
-		}
-		if err := json.NewDecoder(r.Body).Decode(&renameRequest); err != nil {
-			t.Fatalf("decode rename: %v", err)
-		}
-		_ = json.NewEncoder(w).Encode(map[string]any{"code": 0, "data": map[string]any{}})
-	}))
-	defer api.Close()
-
-	d := New(Config{
-		ID:             "123-main",
-		AccessToken:    "token-1",
-		MainAPIBaseURL: api.URL,
-	})
-	if err := d.Rename(context.Background(), "9001", "new name.mp4"); err != nil {
-		t.Fatalf("Rename() error = %v", err)
-	}
-	if renameRequest["driveId"].(float64) != 0 || renameRequest["fileId"] != "9001" || renameRequest["fileName"] != "new name.mp4" {
-		t.Fatalf("rename request = %#v, want driveId/fileId/fileName", renameRequest)
-	}
-}

backend/internal/drives/p123/types.go

@@ -129,27 +129,6 @@ type mkdirResp struct {
 	} `json:"data"`
 }
 
-type uploadResp struct {
-	Data struct {
-		AccessKeyID     string `json:"AccessKeyId"`
-		Bucket          string `json:"Bucket"`
-		Key             string `json:"Key"`
-		SecretAccessKey string `json:"SecretAccessKey"`
-		SessionToken    string `json:"SessionToken"`
-		FileID          int64  `json:"FileId"`
-		Reuse           bool   `json:"Reuse"`
-		EndPoint        string `json:"EndPoint"`
-		StorageNode     string `json:"StorageNode"`
-		UploadID        string `json:"UploadId"`
-	} `json:"data"`
-}
-
-type s3PreSignedURLsResp struct {
-	Data struct {
-		PreSignedURLs map[string]string `json:"presignedUrls"`
-	} `json:"data"`
-}
-
 type flexibleTime struct {
 	t time.Time
 }

backend/internal/drives/quark/driver.go

@@ -263,7 +263,7 @@ func (d *Driver) findChildDir(ctx context.Context, parent, name string) (string,
 	return "", nil
 }
 
-// ---------- 上传（第一版不实现，走本地预览视频兜底） ----------
+// ---------- 上传（第一版不实现，走本地 teaser 兜底） ----------
 
 func (d *Driver) Upload(ctx context.Context, parentID, name string, r io.Reader, size int64) (string, error) {
 	return "", drives.ErrNotSupported

backend/internal/drives/spider91/crawler.go

@@ -21,7 +21,6 @@ import (
 	"time"
 
 	"github.com/video-site/backend/internal/catalog"
-	"github.com/video-site/backend/internal/mediaasset"
 	"golang.org/x/net/proxy"
 )
 
@@ -62,7 +61,7 @@ type CrawlerConfig struct {
 	// DownloadTimeout 限制单条视频/封面下载的耗时。
 	DownloadTimeout time.Duration
 
-	// OnNewVideo 是新视频成功入库后的回调，用于触发预览视频 worker。
+	// OnNewVideo 是新视频成功入库后的回调，用于触发 teaser worker。
 	OnNewVideo func(v *catalog.Video)
 }
 
@@ -236,7 +235,7 @@ type spiderVideoEntry struct {
 //  3. Go 端 bufio.Scanner 按行读：每行立即下载视频和封面、入库。
 //     这样 "Python 翻页找下一个" 与 "Go 下载当前一个" 在时间上重叠，缩短整轮耗时；
 //     更重要的是不会让前几个下载耽误后面签名链接 e= 过期。
-//  4. 全部消费完 + 子进程退出 → 返回 CrawlResult。预览视频不在此处入队，
+//  4. 全部消费完 + 子进程退出 → 返回 CrawlResult。teaser 不在此处入队，
 //     由调用方 (App.runSpider91Crawl) 在 RunOnce 后统一调 enqueueDriveGeneration。
 //
 // targetNew <= 0 会被规范化成 spider91DefaultTargetNew（15）。
@@ -331,16 +330,6 @@ func (c *Crawler) RunOnce(ctx context.Context, targetNew int) (*CrawlResult, err
 			break
 		}
 		videoID := buildVideoID(c.cfg.Driver.ID(), sourceID)
-		deleted, err := c.cfg.Catalog.IsVideoDeleted(ctx, videoID)
-		if err != nil {
-			log.Printf("[spider91] drive=%s viewkey=%s source_id=%s check deleted: %v", c.cfg.Driver.ID(), item.Viewkey, sourceID, err)
-			result.Failed++
-			continue
-		}
-		if deleted {
-			result.Skipped++
-			continue
-		}
 		if existing, _ := c.cfg.Catalog.GetVideo(ctx, videoID); existing != nil {
 			result.Skipped++
 			continue
@@ -536,7 +525,7 @@ func (c *Crawler) processOne(ctx context.Context, videoID string, item spiderVid
 			log.Printf("[spider91] drive=%s mkdir common thumbs: %v", c.cfg.Driver.ID(), err)
 			thumbReady = false
 		} else {
-			dst := mediaasset.ThumbnailPathInDir(c.cfg.CommonThumbDir, videoID)
+			dst := filepath.Join(c.cfg.CommonThumbDir, videoID+".jpg")
 			if err := copyFileAtomic(thumbPath, dst); err != nil {
 				log.Printf("[spider91] drive=%s viewkey=%s source_id=%s copy thumb to common dir: %v", c.cfg.Driver.ID(), viewkey, sourceID, err)
 				thumbReady = false

backend/internal/drives/spider91/driver.go

@@ -138,7 +138,7 @@ func (d *Driver) Stat(ctx context.Context, fileID string) (*drives.Entry, error)
 
 // StreamURL 返回本地视频文件路径，给 ffmpeg / 上层服务使用。
 // 注意：proxy.serve 不能直接处理本地路径，回放要走 api.handleSpider91Video。
-// 预览视频/封面 worker 通过 localPreviewLink 兜底走本地文件，刚好兼容 path 形式的 URL。
+// teaser/封面 worker 通过 localPreviewLink 兜底走本地文件，刚好兼容 path 形式的 URL。
 func (d *Driver) StreamURL(ctx context.Context, fileID string) (*drives.StreamLink, error) {
 	path, err := d.VideoPath(fileID)
 	if err != nil {

backend/internal/mediaasset/paths.go

@@ -1,69 +0,0 @@
-package mediaasset
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"path/filepath"
-	"strings"
-)
-
-const maxPlainStemBytes = 180
-const maxLegacyFilenameBytes = 255
-
-func PreviewPath(localDir, videoID string) string {
-	return filepath.Join(localDir, PreviewFilename(videoID))
-}
-
-func ThumbnailPath(localDir, videoID string) string {
-	return ThumbnailPathInDir(filepath.Join(localDir, "thumbs"), videoID)
-}
-
-func ThumbnailPathInDir(thumbDir, videoID string) string {
-	return filepath.Join(thumbDir, ThumbnailFilename(videoID))
-}
-
-func PreviewPathCandidates(localDir, videoID string) []string {
-	return pathCandidates(localDir, videoID, ".mp4", "")
-}
-
-func ThumbnailPathCandidates(localDir, videoID string) []string {
-	return pathCandidates(localDir, videoID, ".jpg", "thumbs")
-}
-
-func PreviewFilename(videoID string) string {
-	return safeFilename(videoID, ".mp4")
-}
-
-func ThumbnailFilename(videoID string) string {
-	return safeFilename(videoID, ".jpg")
-}
-
-func pathCandidates(localDir, videoID, ext, subdir string) []string {
-	safe := safeFilename(videoID, ext)
-	legacy := videoID + ext
-	base := localDir
-	if subdir != "" {
-		base = filepath.Join(base, subdir)
-	}
-	out := []string{filepath.Join(base, safe)}
-	if legacy != safe && isPlainSafeStem(videoID) && len([]byte(legacy)) <= maxLegacyFilenameBytes {
-		out = append(out, filepath.Join(base, legacy))
-	}
-	return out
-}
-
-func safeFilename(videoID, ext string) string {
-	if isPlainSafeStem(videoID) && len([]byte(videoID))+len(ext) <= maxPlainStemBytes {
-		return videoID + ext
-	}
-	sum := sha256.Sum256([]byte(videoID))
-	return "v-" + hex.EncodeToString(sum[:]) + ext
-}
-
-func isPlainSafeStem(value string) bool {
-	value = strings.TrimSpace(value)
-	if value == "" || value == "." || value == ".." {
-		return false
-	}
-	return !strings.ContainsAny(value, `/\`+"\x00")
-}

backend/internal/mediaasset/paths_test.go

@@ -1,56 +0,0 @@
-package mediaasset
-
-import (
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestFilenamesKeepShortSafeIDs(t *testing.T) {
-	if got := ThumbnailFilename("video-1"); got != "video-1.jpg" {
-		t.Fatalf("thumbnail filename = %q, want video-1.jpg", got)
-	}
-	if got := PreviewFilename("video-1"); got != "video-1.mp4" {
-		t.Fatalf("preview filename = %q, want video-1.mp4", got)
-	}
-}
-
-func TestFilenamesHashLongOrUnsafeIDs(t *testing.T) {
-	longID := "localstorage-" + strings.Repeat("x", 240)
-	got := ThumbnailFilename(longID)
-	if !strings.HasPrefix(got, "v-") || !strings.HasSuffix(got, ".jpg") {
-		t.Fatalf("thumbnail filename = %q, want hashed jpg", got)
-	}
-	if len([]byte(got)) >= len([]byte(longID+".jpg")) {
-		t.Fatalf("thumbnail filename = %q should be shorter than original id", got)
-	}
-
-	unsafe := ThumbnailFilename("dir/video")
-	if unsafe == "dir/video.jpg" || strings.ContainsAny(unsafe, `/\`) {
-		t.Fatalf("unsafe thumbnail filename = %q, want hashed single filename", unsafe)
-	}
-}
-
-func TestThumbnailPathCandidatesIncludeLegacyForHashedIDs(t *testing.T) {
-	localDir := t.TempDir()
-	mediumID := "localstorage-" + strings.Repeat("x", 190)
-	got := ThumbnailPathCandidates(localDir, mediumID)
-	if len(got) != 2 {
-		t.Fatalf("candidates = %#v, want hashed and legacy paths", got)
-	}
-	if got[0] != ThumbnailPath(localDir, mediumID) {
-		t.Fatalf("first candidate = %q, want safe path %q", got[0], ThumbnailPath(localDir, mediumID))
-	}
-	if filepath.Base(got[1]) != mediumID+".jpg" {
-		t.Fatalf("legacy candidate = %q, want original id jpg", got[1])
-	}
-}
-
-func TestThumbnailPathCandidatesSkipOverlongLegacy(t *testing.T) {
-	localDir := t.TempDir()
-	longID := "localstorage-" + strings.Repeat("x", 240)
-	got := ThumbnailPathCandidates(localDir, longID)
-	if len(got) != 1 {
-		t.Fatalf("candidates = %#v, want only hashed path for overlong id", got)
-	}
-}

backend/internal/nightly/runner.go

@@ -5,11 +5,11 @@
 // "扫描所有网盘"):
 //
 //	Phase 1: for each non-spider91 cloud drive
-//	           scan + delete-detection + enqueue thumb + enqueue preview video
-//	         wait until all thumb / preview-video queues are idle
+//	           scan + delete-detection + enqueue thumb + enqueue teaser
+//	         wait until all thumb / teaser queues are idle
 //	Phase 2: if any spider91 drive configured
-//	           crawl + enqueue preview video for new videos
-//	         wait until preview-video queues are idle
+//	           crawl + enqueue teaser for new videos
+//	         wait until teaser queues are idle
 //	Phase 3: spider91 → cloud migration (single sweep, captcha cooldown still
 //	         honored within this call)
 //	Phase 4: cleanup duplicate local preview/thumbnail assets after sampled
@@ -76,10 +76,10 @@ type Config struct {
 	ListSpider91Drives func(ctx context.Context) []string
 
 	// RunSpider91Crawl synchronously runs one crawl cycle (downloads + thumbs +
-	// preview-video enqueue) for a single spider91 drive.
+	// teaser enqueue) for a single spider91 drive.
 	RunSpider91Crawl func(ctx context.Context, driveID string)
 
-	// WaitPreviewQueuesIdle blocks until both the thumbnail and preview-video queues
+	// WaitPreviewQueuesIdle blocks until both the thumbnail and teaser queues
 	// across all drives are drained (queue empty + no in-flight task). It must
 	// honor ctx cancellation.
 	WaitPreviewQueuesIdle func(ctx context.Context) error
@@ -115,7 +115,6 @@ type Runner struct {
 	queued         bool
 	startedAt      time.Time
 	lastFinishedAt time.Time
-	currentCancel  context.CancelFunc
 }
 
 // New constructs a Runner. cfg is shallow-copied; defaults are applied.
@@ -176,28 +175,6 @@ func (r *Runner) TriggerNow() bool {
 	}
 }
 
-// StopCurrent cancels the currently running pipeline and drops one queued
-// manual trigger, if present. It returns true when there was something to stop.
-func (r *Runner) StopCurrent() bool {
-	r.stateMu.Lock()
-	wasRunning := r.running
-	wasQueued := r.queued
-	cancel := r.currentCancel
-	r.queued = false
-	r.stateMu.Unlock()
-
-	if wasQueued {
-		select {
-		case <-r.trigger:
-		default:
-		}
-	}
-	if cancel != nil {
-		cancel()
-	}
-	return wasRunning || wasQueued || cancel != nil
-}
-
 func (r *Runner) Status() Status {
 	r.stateMu.Lock()
 	running := r.running
@@ -255,25 +232,14 @@ func shouldRun(now time.Time, lastRunDate string) bool {
 //
 // 流水线没有总耗时上限：一直跑到 ctx 取消（进程退出）或所有 phase 完成。
 func (r *Runner) runPipelineLocked(ctx context.Context, manual bool) {
-	if manual {
-		r.stateMu.Lock()
-		queued := r.queued
-		r.stateMu.Unlock()
-		if !queued {
-			log.Printf("[nightly] manual trigger was canceled before start")
-			return
-		}
-	}
 	if !r.runMu.TryLock() {
 		log.Printf("[nightly] another pipeline is already running, skipping this trigger")
 		return
 	}
 
 	started := r.cfg.Now()
-	runCtx, cancel := context.WithCancel(ctx)
-	r.markStarted(started, cancel)
+	r.markStarted(started)
 	defer func() {
-		cancel()
 		r.markFinished(r.cfg.Now())
 		r.runMu.Unlock()
 	}()
@@ -284,7 +250,7 @@ func (r *Runner) runPipelineLocked(ctx context.Context, manual bool) {
 	}
 	log.Printf("[nightly] pipeline (%s) start", mode)
 
-	r.runPipeline(runCtx)
+	r.runPipeline(ctx)
 
 	finished := r.cfg.Now()
 	log.Printf("[nightly] pipeline (%s) finish; took=%s", mode, finished.Sub(started).Round(time.Second))
@@ -298,13 +264,12 @@ func (r *Runner) runPipelineLocked(ctx context.Context, manual bool) {
 	}
 }
 
-func (r *Runner) markStarted(started time.Time, cancel context.CancelFunc) {
+func (r *Runner) markStarted(started time.Time) {
 	r.stateMu.Lock()
 	defer r.stateMu.Unlock()
 	r.running = true
 	r.queued = false
 	r.startedAt = started
-	r.currentCancel = cancel
 }
 
 func (r *Runner) markFinished(finished time.Time) {
@@ -313,7 +278,6 @@ func (r *Runner) markFinished(finished time.Time) {
 	r.running = false
 	r.startedAt = time.Time{}
 	r.lastFinishedAt = finished
-	r.currentCancel = nil
 }
 
 // runPipeline executes the three phases. It returns when the pipeline finishes

backend/internal/nightly/runner_test.go

@@ -395,61 +395,6 @@ func TestStatusTracksQueuedRunningAndFinished(t *testing.T) {
 	}
 }
 
-func TestStopCurrentCancelsRunningPipeline(t *testing.T) {
-	scanStarted := make(chan struct{})
-	scanCanceled := make(chan struct{})
-	var startedOnce sync.Once
-	r := New(Config{
-		Settings: newStubSettings(),
-		ListScanTargets: func(context.Context) []string {
-			return []string{"drive"}
-		},
-		RunScan: func(ctx context.Context, _ string) {
-			startedOnce.Do(func() { close(scanStarted) })
-			<-ctx.Done()
-			close(scanCanceled)
-		},
-	})
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go r.Run(ctx)
-
-	if !r.TriggerNow() {
-		t.Fatal("TriggerNow should queue a manual run")
-	}
-	select {
-	case <-scanStarted:
-	case <-time.After(time.Second):
-		t.Fatal("pipeline did not start")
-	}
-
-	if !r.StopCurrent() {
-		t.Fatal("StopCurrent should report a running pipeline")
-	}
-	select {
-	case <-scanCanceled:
-	case <-time.After(time.Second):
-		t.Fatal("StopCurrent did not cancel pipeline context")
-	}
-}
-
-func TestStopCurrentDropsQueuedTrigger(t *testing.T) {
-	r := New(Config{Settings: newStubSettings()})
-	if !r.TriggerNow() {
-		t.Fatal("TriggerNow should queue a manual run")
-	}
-	if !r.StopCurrent() {
-		t.Fatal("StopCurrent should report a queued pipeline")
-	}
-	if got := r.Status(); got.State != "idle" || got.Running || got.Queued {
-		t.Fatalf("status = %#v, want idle after dropping queued trigger", got)
-	}
-	if !r.TriggerNow() {
-		t.Fatal("TriggerNow should accept a new request after queued stop")
-	}
-}
-
 func TestTriggerNowAcceptsOnlyOneConcurrentRequest(t *testing.T) {
 	r := New(Config{Settings: newStubSettings()})
 

backend/internal/preview/ffmpeg.go

@@ -21,16 +21,15 @@ import (
 
 	"github.com/video-site/backend/internal/catalog"
 	"github.com/video-site/backend/internal/drives"
-	"github.com/video-site/backend/internal/mediaasset"
 )
 
 type Config struct {
 	FFmpegPath      string
 	FFprobePath     string
-	DurationSeconds int // 兼容旧配置；当前预览视频每段固定 3 秒
+	DurationSeconds int // 兼容旧配置；当前 teaser 每段固定 3 秒
 	Width           int
 	Segments        int    // 兼容旧配置；当前 30 秒及以上视频固定使用 4 段
-	LocalDir        string // 本地预览视频和封面目录
+	LocalDir        string // 本地 teaser 和封面目录
 }
 
 type Generator struct {
@@ -237,7 +236,7 @@ func appendUniqueStart(starts []float64, start, eachSec float64) []float64 {
 	return append(starts, start)
 }
 
-// thumbnailOffsets 选封面抽帧的时间点（秒）。独立于预览视频。
+// thumbnailOffsets 选封面抽帧的时间点（秒）。独立于 teaser。
 // 默认取视频中间帧；时长未知时退回早期帧。
 func thumbnailOffsets(duration float64) []float64 {
 	if duration <= 0 {
@@ -270,7 +269,7 @@ func (g *Generator) GenerateThumbnail(ctx context.Context, link *drives.StreamLi
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return "", err
 	}
-	dst := mediaasset.ThumbnailPath(g.cfg.LocalDir, videoID)
+	dst := filepath.Join(dir, videoID+".jpg")
 
 	var lastErr error
 	offsets := thumbnailOffsets(duration)
@@ -384,9 +383,9 @@ func (g *Generator) Probe(ctx context.Context, link *drives.StreamLink) (float64
 	return strconv.ParseFloat(raw, 64)
 }
 
-// --- 预览视频 ---
+// --- Teaser ---
 
-// Generate 拉取预览视频到本地临时文件，返回路径。
+// Generate 拉取 teaser 到本地临时文件，返回路径。
 // 根据 Config.Segments 和视频时长决定是单段还是多段拼接。
 func (g *Generator) Generate(ctx context.Context, link *drives.StreamLink, duration float64) (string, error) {
 	return g.generate(ctx, duration, func(int) (*drives.StreamLink, error) {
@@ -967,10 +966,7 @@ func ffmpegOutputLooksRateLimited(output []byte) bool {
 
 // MoveToLocal 把临时文件改名到稳定位置，返回最终路径
 func (g *Generator) MoveToLocal(tmpPath, videoID string) (string, error) {
-	if err := os.MkdirAll(g.cfg.LocalDir, 0o755); err != nil {
-		return "", err
-	}
-	dst := mediaasset.PreviewPath(g.cfg.LocalDir, videoID)
+	dst := filepath.Join(g.cfg.LocalDir, videoID+".mp4")
 	if err := os.Rename(tmpPath, dst); err != nil {
 		// 跨盘 rename 可能失败，fallback 到 copy
 		if cerr := copyFile(tmpPath, dst); cerr != nil {
@@ -1362,19 +1358,12 @@ func (w *ThumbWorker) Run(ctx context.Context) {
 
 func (w *Worker) processQueued(ctx context.Context, v *catalog.Video) {
 	defer w.queue.release(v)
-	if w.Catalog == nil || v == nil || v.ID == "" {
-		return
-	}
-	current, err := w.Catalog.GetVideo(ctx, v.ID)
-	if err != nil || current.Hidden {
-		return
-	}
-	w.activity.start(current)
+	w.activity.start(v)
 	defer w.activity.done()
 	if !waitForRateLimitCooldown(ctx, &w.rateLimit, "preview", w.Drive) {
 		return
 	}
-	w.process(ctx, current)
+	w.process(ctx, v)
 }
 
 func (w *ThumbWorker) processQueued(ctx context.Context, v *catalog.Video) {
@@ -1517,7 +1506,7 @@ func driveErrorShouldCooldown(d drives.Drive, err error) bool {
 			strings.Contains(text, "request has been blocked") ||
 			strings.Contains(text, "访问被阻断")
 	case "pikpak":
-		// PikPak 在预览视频 / 封面生成阶段（取链或拉直链字节）可能命中：
+		// PikPak 在 teaser / 封面生成阶段（取链或拉直链字节）可能命中：
 		//   - error_code=10  操作频繁
 		//   - HTTP 429 / 5xx / 509 限流和服务端不可用
 		//   - 通用文本：rate limit / too many requests / blocked
@@ -1569,22 +1558,18 @@ func (w *ThumbWorker) process(ctx context.Context, v *catalog.Video) bool {
 	if w.skipIfRateLimited(v) {
 		return false
 	}
-	if w.Catalog == nil || v == nil || v.ID == "" {
-		return false
-	}
 	queued := v
-	loaded, err := w.Catalog.GetVideo(ctx, v.ID)
-	if err != nil || loaded.Hidden {
-		return false
-	}
-	if loaded.PreviewLocal == "" {
-		loaded.PreviewLocal = queued.PreviewLocal
-	}
-	current := loaded
-	v = loaded
-	if loaded.ThumbnailURL != "" && loaded.DurationSeconds > 0 {
-		_ = w.Catalog.UpdateVideoMeta(ctx, v.ID, catalog.VideoMetaPatch{ThumbnailStatus: "ready"})
-		return false
+	current := v
+	if loaded, err := w.Catalog.GetVideo(ctx, v.ID); err == nil {
+		if loaded.PreviewLocal == "" {
+			loaded.PreviewLocal = queued.PreviewLocal
+		}
+		current = loaded
+		v = loaded
+		if loaded.ThumbnailURL != "" && loaded.DurationSeconds > 0 {
+			_ = w.Catalog.UpdateVideoMeta(ctx, v.ID, catalog.VideoMetaPatch{ThumbnailStatus: "ready"})
+			return false
+		}
 	}
 	if current.ThumbnailURL != "" {
 		durationBackfillFailed := false
@@ -1681,18 +1666,13 @@ func (w *ThumbWorker) probeDuration(ctx context.Context, v *catalog.Video, link
 }
 
 func (w *ThumbWorker) generateThumbnailFromLink(ctx context.Context, v *catalog.Video, link *drives.StreamLink) error {
-	local, err := w.Gen.GenerateThumbnail(ctx, link, v.ID, float64(v.DurationSeconds))
-	if err != nil {
+	if _, err := w.Gen.GenerateThumbnail(ctx, link, v.ID, float64(v.DurationSeconds)); err != nil {
 		return err
 	}
-	if err := w.Catalog.UpdateVideoMeta(ctx, v.ID, catalog.VideoMetaPatch{
+	_ = w.Catalog.UpdateVideoMeta(ctx, v.ID, catalog.VideoMetaPatch{
 		ThumbnailURL:    "/p/thumb/" + v.ID,
 		ThumbnailStatus: "ready",
-	}); err != nil {
-		_ = os.Remove(local)
-		log.Printf("[thumb] update %s after generate: %v", v.Title, err)
-		return nil
-	}
+	})
 	log.Printf("[thumb] ready %s", v.Title)
 	return nil
 }
@@ -1749,7 +1729,7 @@ func (w *Worker) process(ctx context.Context, v *catalog.Video) {
 		}
 	}
 
-	// 2) 预览视频
+	// 2) teaser
 	tmp, err := w.generateTeaser(ctx, v, link, duration)
 	if err != nil {
 		if w.pauseForRecoverableError(err, "generate", v.Title) {
@@ -1767,11 +1747,7 @@ func (w *Worker) process(ctx context.Context, v *catalog.Video) {
 	}
 
 	removePreviousLocalTeaser(v.PreviewLocal, local)
-	if err := w.Catalog.UpdatePreview(ctx, v.ID, local, "ready"); err != nil {
-		removePreviousLocalTeaser(local, "")
-		log.Printf("[preview] update %s after generate: %v", v.Title, err)
-		return
-	}
+	w.Catalog.UpdatePreview(ctx, v.ID, local, "ready")
 	log.Printf("[preview] ready %s (duration=%.1fs)", v.Title, duration)
 }
 

backend/internal/proxy/proxy.go

@@ -216,7 +216,7 @@ func (p *Proxy) serve(w http.ResponseWriter, r *http.Request, link *drives.Strea
 	_, _ = io.Copy(w, resp.Body)
 }
 
-// ServeLocal 服务本地预览视频文件
+// ServeLocal 服务本地 teaser 文件
 func (p *Proxy) ServeLocal(w http.ResponseWriter, r *http.Request, path string) {
 	http.ServeFile(w, r, path)
 }

backend/internal/scanner/scanner.go

@@ -23,7 +23,7 @@ type Scanner struct {
 	//
 	// nil / 空集合 → 行为等同于不跳过任何目录。
 	SkipDirIDs map[string]struct{}
-	// 回调：新视频被加入后触发预览视频生成
+	// 回调：新视频被加入后触发 teaser 生成
 	OnNewVideo func(v *catalog.Video)
 	// ProgressInterval 控制扫描内部 heartbeat 的最小输出间隔。
 	// 0 → 默认 30s；< 0 → 关闭 heartbeat（仅留外层 start / done 两行）。
@@ -128,7 +128,7 @@ func (s *Scanner) walk(ctx context.Context, dirID, dirName string, stats *Stats,
 
 	for _, e := range entries {
 		if e.IsDir {
-			// 跳过 previews 目录，避免扫到自己生成的预览视频
+			// 跳过 previews 目录，避免扫到自己生成的 teaser
 			if strings.EqualFold(e.Name, "previews") {
 				continue
 			}
@@ -154,14 +154,6 @@ func (s *Scanner) walk(ctx context.Context, dirID, dirName string, stats *Stats,
 		stats.SeenFileIDs[e.ID] = struct{}{}
 
 		id := s.Drive.Kind() + "-" + s.Drive.ID() + "-" + e.ID
-		if deleted, err := s.Catalog.IsDeletedVideoCandidate(ctx, id, s.Drive.ID(), e.ID, e.Hash, e.Name, e.Size); err != nil {
-			stats.Errors++
-			log.Printf("[scanner] check deleted video %s error: %v", id, err)
-			continue
-		} else if deleted {
-			continue
-		}
-
 		parsed := Parse(e.Name)
 		if parsed.Title == "" {
 			parsed.Title = strings.TrimSuffix(e.Name, ext)

backend/internal/scanner/scanner_test.go

@@ -90,61 +90,6 @@ func TestRunIgnoresZeroSizeVideoFiles(t *testing.T) {
 	}
 }
 
-func TestRunSkipsAdminDeletedVideo(t *testing.T) {
-	ctx := context.Background()
-	cat, err := catalog.Open(t.TempDir() + "/catalog.db")
-	if err != nil {
-		t.Fatalf("open catalog: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := cat.Close(); err != nil {
-			t.Fatalf("close catalog: %v", err)
-		}
-	})
-
-	now := time.Now()
-	if err := cat.UpsertVideo(ctx, &catalog.Video{
-		ID:          "fake-drive-file-1",
-		DriveID:     "drive",
-		FileID:      "file-1",
-		FileName:    "clip.mp4",
-		ContentHash: "HASH-1",
-		Title:       "Deleted Clip",
-		Size:        123,
-		PublishedAt: now,
-		CreatedAt:   now,
-		UpdatedAt:   now,
-	}); err != nil {
-		t.Fatalf("seed video: %v", err)
-	}
-	if err := cat.DeleteVideoWithTombstone(ctx, "fake-drive-file-1"); err != nil {
-		t.Fatalf("delete with tombstone: %v", err)
-	}
-
-	drv := &scannerFakeDrive{
-		entries: []drives.Entry{{
-			ID:       "file-1",
-			Name:     "clip.mp4",
-			Size:     123,
-			Hash:     "hash-1",
-			MimeType: "video/mp4",
-			ModTime:  now,
-		}},
-	}
-	sc := New(cat, drv, []string{".mp4"}, nil, nil)
-
-	stats, err := sc.Run(ctx, "")
-	if err != nil {
-		t.Fatalf("scan: %v", err)
-	}
-	if stats.Added != 0 {
-		t.Fatalf("added = %d, want 0", stats.Added)
-	}
-	if _, err := cat.GetVideo(ctx, "fake-drive-file-1"); err != sql.ErrNoRows {
-		t.Fatalf("deleted video was recreated, get error = %v", err)
-	}
-}
-
 func TestRunDoesNotBackfillRemoteThumbnailForExistingVideo(t *testing.T) {
 	ctx := context.Background()
 	cat, err := catalog.Open(t.TempDir() + "/catalog.db")

backend/internal/spider91migrate/migrator.go

@@ -1,5 +1,5 @@
 // Package spider91migrate 周期性把 spider91 drive 下载到本地的视频
-// 上传到一个指定的目标 drive 目录（PikPak、115、123 或 OneDrive），上传成功后：
+// 上传到一个指定的目标 drive 目录（PikPak、115 或 OneDrive），上传成功后：
 //
 //   - 改写 catalog 行：drive_id / file_id / content_hash 改成目标盘的；
 //     视频自身的 id 不变（仍是 spider91-<driveID>-<viewkey>），video_tags、
@@ -31,19 +31,16 @@ import (
 	"github.com/video-site/backend/internal/drives"
 	"github.com/video-site/backend/internal/drives/onedrive"
 	"github.com/video-site/backend/internal/drives/p115"
-	"github.com/video-site/backend/internal/drives/p123"
 	"github.com/video-site/backend/internal/drives/pikpak"
 	"github.com/video-site/backend/internal/drives/spider91"
-	"github.com/video-site/backend/internal/mediaasset"
 )
 
 // uploadTarget 是 migrator 调用目标 drive 的最小接口。任何一种"接收 spider91 上传"的
-// 网盘都要实现它；当前 PikPak、115、123 和 OneDrive 各自通过适配器满足。
+// 网盘都要实现它；当前 PikPak 和 115 各自通过适配器满足。
 //
 // 这一层抽象把"迁移调用方"和"具体盘的 SDK 协议"解耦：
 //   - PikPak 走 GCID + OSS PutObject（pikpak.UploadResult）
 //   - 115   走 SHA1   + 秒传 / OSS / 分片（p115.UploadResult）
-//   - 123   走 MD5    + 秒传 / S3 预签名分片（p123.UploadResult）
 //   - OneDrive 走 SHA1 + 小文件 PUT / 大文件 upload session
 //
 // 各家返回值都被归一成本地的 UploadResult，并在 catalog 改写阶段统一处理。
@@ -59,7 +56,7 @@ type uploadTarget interface {
 // UploadResult 是 uploadTarget.UploadAndReportHash 的归一返回。
 //
 // FileID  目标盘上的新文件 ID；
-// Hash    GCID（PikPak）、MD5 HEX（123）或 SHA1 HEX（115 / OneDrive），写入 catalog.content_hash 用于跨盘去重；
+// Hash    GCID（PikPak）或 SHA1 HEX（115 / OneDrive），写入 catalog.content_hash 用于跨盘去重；
 // Size    实际上传字节数。
 type UploadResult struct {
 	FileID string
@@ -69,7 +66,7 @@ type UploadResult struct {
 
 const spider91UploadDirName = "91 Spider"
 
-// pikpakAdapter / p115Adapter / p123Adapter / onedriveAdapter 把具体 driver 包装成 uploadTarget。
+// pikpakAdapter / p115Adapter / onedriveAdapter 把具体 driver 包装成 uploadTarget。
 //
 // 之所以不让 driver 直接实现 uploadTarget：
 //
@@ -118,27 +115,6 @@ func (a *p115Adapter) Rename(ctx context.Context, fileID, newName string) error
 	return a.d.Rename(ctx, fileID, newName)
 }
 
-type p123Adapter struct {
-	d *p123.Driver
-}
-
-func (a *p123Adapter) ID() string     { return a.d.ID() }
-func (a *p123Adapter) Kind() string   { return a.d.Kind() }
-func (a *p123Adapter) RootID() string { return a.d.RootID() }
-func (a *p123Adapter) EnsureDir(ctx context.Context, pathFromRoot string) (string, error) {
-	return a.d.EnsureDir(ctx, pathFromRoot)
-}
-func (a *p123Adapter) UploadAndReportHash(ctx context.Context, parentID, name string, r io.Reader, size int64) (UploadResult, error) {
-	res, err := a.d.UploadAndReportHash(ctx, parentID, name, r, size)
-	if err != nil {
-		return UploadResult{}, err
-	}
-	return UploadResult{FileID: res.FileID, Hash: res.Hash, Size: res.Size}, nil
-}
-func (a *p123Adapter) Rename(ctx context.Context, fileID, newName string) error {
-	return a.d.Rename(ctx, fileID, newName)
-}
-
 type onedriveAdapter struct {
 	d *onedrive.Driver
 }
@@ -168,8 +144,6 @@ func adaptUploadTarget(d drives.Drive) (uploadTarget, error) {
 		return &pikpakAdapter{d: v}, nil
 	case *p115.Driver:
 		return &p115Adapter{d: v}, nil
-	case *p123.Driver:
-		return &p123Adapter{d: v}, nil
 	case *onedrive.Driver:
 		return &onedriveAdapter{d: v}, nil
 	case uploadTarget:
@@ -631,7 +605,7 @@ func (m *Migrator) preserveCrawledThumbnail(ctx context.Context, src *spider91.D
 		log.Printf("[spider91migrate] %s mkdir common thumbs: %v", v.ID, err)
 		return
 	}
-	dst := mediaasset.ThumbnailPathInDir(commonDir, v.ID)
+	dst := filepath.Join(commonDir, v.ID+".jpg")
 	if _, err := os.Stat(dst); err != nil {
 		if !os.IsNotExist(err) {
 			log.Printf("[spider91migrate] %s stat common thumb: %v", v.ID, err)
@@ -785,7 +759,7 @@ func (m *Migrator) cleanupOldLocalVideos(ctx context.Context, src *spider91.Driv
 	return deleted, nil
 }
 
-// backfillFileNames 扫描目标 drive（PikPak、115、123 或 OneDrive）下所有 spider91-* 起始 ID 的视频，
+// backfillFileNames 扫描目标 drive（PikPak、115 或 OneDrive）下所有 spider91-* 起始 ID 的视频，
 // 对文件名不是 desiredPikPakName(...) 期望格式的，调 target.Rename 修正，
 // 并把 catalog.file_name 同步到新名字。
 //

backend/internal/spider91migrate/migrator_test.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/video-site/backend/internal/catalog"
 	"github.com/video-site/backend/internal/drives"
-	"github.com/video-site/backend/internal/drives/p123"
 	"github.com/video-site/backend/internal/drives/pikpak"
 	"github.com/video-site/backend/internal/drives/spider91"
 )
@@ -135,19 +134,6 @@ func (d *fakeP115) Kind() string { return "p115" }
 var _ drives.Drive = (*fakeP115)(nil)
 var _ uploadTarget = (*fakeP115)(nil)
 
-type fakeP123 struct {
-	*fakePikPak
-}
-
-func newFakeP123(id, rootID string) *fakeP123 {
-	return &fakeP123{fakePikPak: newFakePikPak(id, rootID)}
-}
-
-func (d *fakeP123) Kind() string { return "p123" }
-
-var _ drives.Drive = (*fakeP123)(nil)
-var _ uploadTarget = (*fakeP123)(nil)
-
 type fakeOneDrive struct {
 	*fakePikPak
 }
@@ -960,66 +946,6 @@ func TestRunOnceMigratesToP115Target(t *testing.T) {
 	}
 }
 
-func TestRunOnceMigratesToP123Target(t *testing.T) {
-	cat := setupCatalog(t)
-	src, _ := setupSpider91(t)
-	target := newFakeP123("p123-target", "p123-root-id")
-	reg := newFakeRegistry()
-	reg.Add(src)
-	reg.Add(target)
-
-	now := time.Now()
-	id := writeSpider91Video(t, cat, src, "vk-123-001", ".mp4", []byte("video bytes 123"), now)
-
-	m := New(Config{
-		Catalog:          cat,
-		Registry:         reg,
-		GetTargetDriveID: func() string { return target.ID() },
-		KeepLatestN:      -1,
-	})
-	m.runOnce(context.Background())
-
-	if target.uploadCalls != 1 {
-		t.Fatalf("p123 upload calls = %d, want 1", target.uploadCalls)
-	}
-
-	got, err := cat.GetVideo(context.Background(), id)
-	if err != nil {
-		t.Fatalf("get video: %v", err)
-	}
-	if got.DriveID != target.ID() {
-		t.Fatalf("drive_id = %q, want %q", got.DriveID, target.ID())
-	}
-	wantName := "Sample vk-123-001-001.mp4"
-	if _, ok := target.gotBodies[wantName]; !ok {
-		t.Fatalf("p123 did not receive expected upload name %q (got names: %v)", wantName, keysOf(target.gotBodies))
-	}
-	if gotParent := target.gotParents[wantName]; gotParent != "p123-root-id/"+spider91UploadDirName {
-		t.Fatalf("p123 upload parent = %q, want root/91 Spider", gotParent)
-	}
-	if len(target.ensureCalls) != 1 || target.ensureCalls[0] != spider91UploadDirName {
-		t.Fatalf("p123 ensure calls = %#v, want %q", target.ensureCalls, spider91UploadDirName)
-	}
-	if got.FileID != "remote-"+wantName {
-		t.Fatalf("file_id = %q, want %q", got.FileID, "remote-"+wantName)
-	}
-	if got.FileName != wantName {
-		t.Fatalf("file_name = %q, want %q", got.FileName, wantName)
-	}
-	if got.ContentHash == "" {
-		t.Fatal("content_hash should be set after p123 migration")
-	}
-
-	videoPath, _ := src.VideoPath("vk-123-001.mp4")
-	if _, err := os.Stat(videoPath); !os.IsNotExist(err) {
-		t.Fatalf("local mp4 still exists after p123 migration or stat error: %v", err)
-	}
-	thumbPath, _ := src.ThumbPath("vk-123-001.jpg")
-	if _, err := os.Stat(thumbPath); !os.IsNotExist(err) {
-		t.Fatalf("local thumb still exists after p123 migration or stat error: %v", err)
-	}
-}
-
 func TestRunOnceMigratesToOneDriveTarget(t *testing.T) {
 	cat := setupCatalog(t)
 	src, _ := setupSpider91(t)
@@ -1080,22 +1006,7 @@ func TestRunOnceMigratesToOneDriveTarget(t *testing.T) {
 	}
 }
 
-func TestAdaptUploadTargetSupportsP123Driver(t *testing.T) {
-	d := p123.New(p123.Config{
-		ID:          "p123-target",
-		RootID:      "root-123",
-		AccessToken: "token-1",
-	})
-	target, err := adaptUploadTarget(d)
-	if err != nil {
-		t.Fatalf("adaptUploadTarget() error = %v", err)
-	}
-	if target.ID() != "p123-target" || target.Kind() != "p123" || target.RootID() != "root-123" {
-		t.Fatalf("target id/kind/root = %q/%q/%q, want p123-target/p123/root-123", target.ID(), target.Kind(), target.RootID())
-	}
-}
-
-// TestResolveTargetRejectsUnsupportedKind 验证当目标 drive 既不是 PikPak、115、123 也不是 OneDrive 时，
+// TestResolveTargetRejectsUnsupportedKind 验证当目标 drive 既不是 PikPak、115 也不是 OneDrive 时，
 // resolveTarget 拒绝并返回 error，让 runOnce 静默跳过（不会做破坏性变更）。
 func TestResolveTargetRejectsUnsupportedKind(t *testing.T) {
 	cat := setupCatalog(t)

backend/internal/storageusage/storageusage.go

@@ -5,8 +5,6 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-
-	"github.com/video-site/backend/internal/mediaasset"
 )
 
 type VideoAssetRef struct {
@@ -73,15 +71,14 @@ func Compute(
 			continue
 		}
 		driveUsage := out.Drives[ref.DriveID]
-		for _, thumbPath := range mediaasset.ThumbnailPathCandidates(localDir, ref.ID) {
-			if size, exists, err := regularFileSize(thumbPath); err != nil {
-				return Usage{}, err
-			} else if exists {
-				key := ref.DriveID + "\x00thumb\x00" + thumbPath
-				if !seen[key] {
-					driveUsage.ThumbnailBytes += size
-					seen[key] = true
-				}
+		thumbPath := filepath.Join(localDir, "thumbs", ref.ID+".jpg")
+		if size, exists, err := regularFileSize(thumbPath); err != nil {
+			return Usage{}, err
+		} else if exists {
+			key := ref.DriveID + "\x00thumb\x00" + thumbPath
+			if !seen[key] {
+				driveUsage.ThumbnailBytes += size
+				seen[key] = true
 			}
 		}
 

backend/internal/storageusage/storageusage_test.go

@@ -3,10 +3,7 @@ package storageusage
 import (
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
-
-	"github.com/video-site/backend/internal/mediaasset"
 )
 
 func TestComputeCountsLocalThumbnailsAndTeasersByDrive(t *testing.T) {
@@ -16,8 +13,6 @@ func TestComputeCountsLocalThumbnailsAndTeasersByDrive(t *testing.T) {
 	}
 	writeSizedFile(t, filepath.Join(localDir, "thumbs", "video-a.jpg"), 3)
 	writeSizedFile(t, filepath.Join(localDir, "thumbs", "video-b.jpg"), 5)
-	longID := "localstorage-" + strings.Repeat("x", 240)
-	writeSizedFile(t, mediaasset.ThumbnailPath(localDir, longID), 13)
 	teaserA := filepath.Join(localDir, "video-a.mp4")
 	teaserB := filepath.Join(localDir, "video-b.mp4")
 	writeSizedFile(t, teaserA, 7)
@@ -29,7 +24,6 @@ func TestComputeCountsLocalThumbnailsAndTeasersByDrive(t *testing.T) {
 		{ID: "video-a", DriveID: "drive-a", PreviewLocal: teaserA},
 		{ID: "video-a-copy", DriveID: "drive-a", PreviewLocal: teaserA},
 		{ID: "video-b", DriveID: "drive-b", PreviewLocal: teaserB},
-		{ID: longID, DriveID: "drive-b"},
 		{ID: "outside", DriveID: "drive-b", PreviewLocal: outside},
 		{ID: "unknown-drive-video", DriveID: "missing", PreviewLocal: teaserB},
 	}, []string{"drive-a", "drive-b"}, func(string) (DiskStats, error) {
@@ -47,11 +41,11 @@ func TestComputeCountsLocalThumbnailsAndTeasersByDrive(t *testing.T) {
 		t.Fatalf("drive-a usage = %#v, want thumbnails=3 teaser=7 total=10", driveA)
 	}
 	driveB := got.Drives["drive-b"]
-	if driveB.ThumbnailBytes != 18 || driveB.TeaserBytes != 11 || driveB.TotalBytes != 29 {
-		t.Fatalf("drive-b usage = %#v, want thumbnails=18 teaser=11 total=29", driveB)
+	if driveB.ThumbnailBytes != 5 || driveB.TeaserBytes != 11 || driveB.TotalBytes != 16 {
+		t.Fatalf("drive-b usage = %#v, want thumbnails=5 teaser=11 total=16", driveB)
 	}
-	if got.ThumbnailBytes != 21 || got.TeaserBytes != 18 || got.TotalBytes != 39 {
-		t.Fatalf("totals = %#v, want thumbnails=21 teaser=18 total=39", got)
+	if got.ThumbnailBytes != 8 || got.TeaserBytes != 18 || got.TotalBytes != 26 {
+		t.Fatalf("totals = %#v, want thumbnails=8 teaser=18 total=26", got)
 	}
 }
 

deploy.sh

@@ -49,7 +49,7 @@ Common overrides:
   FRONTEND_PORT=9191      Public web port
   FRONTEND_HOST=0.0.0.0   Public web bind address
   GO_VERSION=1.23.12
-  INSTALL_DEPS=0          Do not install missing Node/Go/ffmpeg/Python runtime deps
+  INSTALL_DEPS=0          Do not install missing Node/Go/ffmpeg
   CONFIGURE_UFW=0         Do not open UFW port automatically
   DEPLOY_USER=<user>      Service user; defaults to sudo user or root
 
@@ -130,25 +130,7 @@ apt_install() {
   export DEBIAN_FRONTEND=noninteractive
   log "installing base packages"
   apt-get update
-  apt-get install -y ca-certificates curl git ffmpeg openssl iproute2 build-essential \
-    python3 python3-requests python3-bs4 python3-lxml python3-socks
-}
-
-verify_spider91_python_deps() {
-  command -v python3 >/dev/null 2>&1 || die "python3 is required for 91Spider"
-  python3 - <<'PY' || die "missing Python modules for 91Spider: requests, bs4, lxml, socks"
-import importlib.util
-import sys
-
-missing = [
-    name
-    for name in ("requests", "bs4", "lxml", "socks")
-    if importlib.util.find_spec(name) is None
-]
-if missing:
-    print("missing Python modules: " + ", ".join(missing), file=sys.stderr)
-    sys.exit(1)
-PY
+  apt-get install -y ca-certificates curl git ffmpeg openssl iproute2 build-essential
 }
 
 install_node() {
@@ -200,7 +182,6 @@ install_dependencies() {
   install_go
   command -v ffmpeg >/dev/null 2>&1 || die "ffmpeg is required"
   command -v ffprobe >/dev/null 2>&1 || die "ffprobe is required"
-  verify_spider91_python_deps
 }
 
 ensure_ownership() {

src/admin/AdminLayout.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { useState } from "react";
 import { NavLink, Outlet, useNavigate } from "react-router-dom";
 import {
   HardDrive,
@@ -9,7 +9,6 @@ import {
   Tags,
   Palette,
   RefreshCw,
-  MoreVertical,
 } from "lucide-react";
 import * as api from "./api";
 import { useAuth } from "./AuthContext";
@@ -20,18 +19,6 @@ export function AdminLayout() {
   const navigate = useNavigate();
   const { show } = useToast();
   const [checkingUpdate, setCheckingUpdate] = useState(false);
-  const [mobileMenuOpen, setMobileMenuOpen] = useState(false);
-
-  useEffect(() => {
-    if (!mobileMenuOpen) return;
-    function onKeyDown(e: KeyboardEvent) {
-      if (e.key === "Escape") {
-        setMobileMenuOpen(false);
-      }
-    }
-    document.addEventListener("keydown", onKeyDown);
-    return () => document.removeEventListener("keydown", onKeyDown);
-  }, [mobileMenuOpen]);
 
   async function handleCheckUpdate() {
     if (checkingUpdate) return;
@@ -127,31 +114,7 @@ export function AdminLayout() {
             退出登录
           </button>
         </div>
-        <button
-          className="admin-sidebar__mobile-menu"
-          onClick={() => setMobileMenuOpen((v) => !v)}
-          aria-label="更多操作"
-        >
-          <MoreVertical size={18} />
-        </button>
       </aside>
-      {mobileMenuOpen && (
-        <div className="admin-sidebar__mobile-overlay" onClick={() => setMobileMenuOpen(false)} />
-      )}
-      <div className={`admin-sidebar__mobile-panel${mobileMenuOpen ? " is-open" : ""}`}>
-        <button
-          className="admin-sidebar__check-update"
-          onClick={() => { handleCheckUpdate(); setMobileMenuOpen(false); }}
-          disabled={checkingUpdate}
-        >
-          <RefreshCw size={14} />
-          {checkingUpdate ? "检查中" : "检查更新"}
-        </button>
-        <button className="admin-sidebar__logout" onClick={() => { handleLogout(); setMobileMenuOpen(false); }}>
-          <LogOut size={14} />
-          退出登录
-        </button>
-      </div>
       <main className="admin-main">
         <Outlet />
       </main>

src/admin/ConfirmModal.tsx

@@ -1,72 +0,0 @@
-import { AlertTriangle } from "lucide-react";
-import { Modal } from "./Modal";
-
-type ConfirmModalProps = {
-  open: boolean;
-  title: string;
-  message: string;
-  details?: string[];
-  confirmText?: string;
-  cancelText?: string;
-  danger?: boolean;
-  centerMessage?: boolean;
-  modalClassName?: string;
-  loading?: boolean;
-  onCancel: () => void;
-  onConfirm: () => void;
-};
-
-export function ConfirmModal({
-  open,
-  title,
-  message,
-  details,
-  confirmText = "确认",
-  cancelText = "取消",
-  danger = false,
-  centerMessage = false,
-  modalClassName = "",
-  loading = false,
-  onCancel,
-  onConfirm,
-}: ConfirmModalProps) {
-  return (
-    <Modal
-      open={open}
-      title={title}
-      onClose={onCancel}
-      className={modalClassName}
-      footer={
-        <>
-          <button type="button" className="admin-btn" onClick={onCancel} disabled={loading}>
-            {cancelText}
-          </button>
-          <button
-            type="button"
-            className={`admin-btn${danger ? " is-danger" : " is-primary"}`}
-            onClick={onConfirm}
-            disabled={loading}
-          >
-            {loading ? "处理中..." : confirmText}
-          </button>
-        </>
-      }
-    >
-      <div className={`admin-confirm${centerMessage ? " is-message-centered" : ""}`}>
-        <div className={`admin-confirm__icon${danger ? " is-danger" : ""}`} aria-hidden={centerMessage}>
-          <AlertTriangle size={20} />
-        </div>
-        <div className="admin-confirm__content">
-          <p className="admin-confirm__message">{message}</p>
-          {details && details.length > 0 && (
-            <ul className="admin-confirm__list">
-              {details.map((item) => (
-                <li key={item}>{item}</li>
-              ))}
-            </ul>
-          )}
-        </div>
-      </div>
-    </Modal>
-  );
-}

src/admin/LoginPage.tsx

@@ -16,7 +16,6 @@ export function LoginPage() {
   const navigate = useNavigate();
   const location = useLocation();
   const { show } = useToast();
-  const passwordMismatch = setupRequired === true && p2.length > 0 && p !== p2;
 
   useEffect(() => {
     let active = true;
@@ -84,9 +83,8 @@ export function LoginPage() {
         </h1>
         <div className="admin-form">
           <div className="admin-form__row">
-            <label htmlFor="admin-login-username">用户名</label>
+            <label>用户名</label>
             <input
-              id="admin-login-username"
               autoFocus
               value={u}
               onChange={(e) => setU(e.target.value)}
@@ -94,9 +92,8 @@ export function LoginPage() {
             />
           </div>
           <div className="admin-form__row">
-            <label htmlFor="admin-login-password">密码</label>
+            <label>密码</label>
             <input
-              id="admin-login-password"
               type="password"
               value={p}
               onChange={(e) => setP(e.target.value)}
@@ -105,28 +102,19 @@ export function LoginPage() {
           </div>
           {setupRequired && (
             <div className="admin-form__row">
-              <label htmlFor="admin-login-password-confirm">确认密码</label>
+              <label>确认密码</label>
               <input
-                id="admin-login-password-confirm"
                 type="password"
                 value={p2}
                 onChange={(e) => setP2(e.target.value)}
                 autoComplete="new-password"
-                className={passwordMismatch ? "is-invalid" : undefined}
-                aria-invalid={passwordMismatch ? "true" : undefined}
-                aria-describedby={passwordMismatch ? "admin-login-password-confirm-error" : undefined}
               />
-              {passwordMismatch && (
-                <div className="admin-form__error" id="admin-login-password-confirm-error">
-                  密码不一致
-                </div>
-              )}
             </div>
           )}
           <button
             className="admin-btn is-primary"
             type="submit"
-            disabled={loading || !u || !p || (setupRequired && (!p2 || passwordMismatch))}
+            disabled={loading || !u || !p || (setupRequired && !p2)}
           >
             {loading
               ? setupRequired

src/admin/Modal.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useId, useRef, ReactNode } from "react";
+import { ReactNode } from "react";
 import { X } from "lucide-react";
 
 type Props = {
@@ -7,66 +7,9 @@ type Props = {
   onClose: () => void;
   children: ReactNode;
   footer?: ReactNode;
-  className?: string;
 };
 
-export function Modal({ open, title, onClose, children, footer, className = "" }: Props) {
-  const dialogRef = useRef<HTMLDivElement>(null);
-  const titleId = useId();
-
-  useEffect(() => {
-    if (!open) return;
-    const previousFocus =
-      document.activeElement instanceof HTMLElement ? document.activeElement : null;
-
-    function onKeyDown(e: KeyboardEvent) {
-      const dialog = dialogRef.current;
-      if (!dialog || !isTopDialog(dialog)) return;
-
-      if (e.key === "Escape") {
-        e.preventDefault();
-        onClose();
-        return;
-      }
-
-      if (e.key !== "Tab") return;
-
-      const focusable = getFocusableElements(dialog);
-      if (focusable.length === 0) {
-        e.preventDefault();
-        dialog.focus();
-        return;
-      }
-
-      const first = focusable[0];
-      const last = focusable[focusable.length - 1];
-      const current = document.activeElement;
-
-      if (e.shiftKey && current === first) {
-        e.preventDefault();
-        last.focus();
-      } else if (!e.shiftKey && current === last) {
-        e.preventDefault();
-        first.focus();
-      }
-    }
-
-    window.setTimeout(() => {
-      const dialog = dialogRef.current;
-      if (!dialog || !isTopDialog(dialog)) return;
-      const first = getFocusableElements(dialog)[0];
-      (first ?? dialog).focus();
-    }, 0);
-
-    document.addEventListener("keydown", onKeyDown);
-    return () => {
-      document.removeEventListener("keydown", onKeyDown);
-      if (previousFocus?.isConnected) {
-        previousFocus.focus();
-      }
-    };
-  }, [open, onClose]);
-
+export function Modal({ open, title, onClose, children, footer }: Props) {
   if (!open) return null;
   return (
     <div
@@ -75,18 +18,10 @@ export function Modal({ open, title, onClose, children, footer, className = "" }
         if (e.target === e.currentTarget) onClose();
       }}
     >
-      <div
-        ref={dialogRef}
-        className={`admin-modal${className ? ` ${className}` : ""}`}
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={titleId}
-        tabIndex={-1}
-      >
+      <div className="admin-modal" role="dialog" aria-modal="true">
         <div className="admin-modal__header">
-          <span id={titleId}>{title}</span>
+          <span>{title}</span>
           <button
-            type="button"
             className="admin-btn"
             onClick={onClose}
             aria-label="关闭"
@@ -101,25 +36,3 @@ export function Modal({ open, title, onClose, children, footer, className = "" }
     </div>
   );
 }
-
-function getFocusableElements(root: HTMLElement): HTMLElement[] {
-  const selectors = [
-    "a[href]",
-    "button:not([disabled])",
-    "textarea:not([disabled])",
-    "input:not([disabled])",
-    "select:not([disabled])",
-    "[tabindex]:not([tabindex='-1'])",
-  ].join(",");
-
-  return Array.from(root.querySelectorAll<HTMLElement>(selectors)).filter(
-    (el) => !el.hasAttribute("disabled") && el.getAttribute("aria-hidden") !== "true"
-  );
-}
-
-function isTopDialog(dialog: HTMLElement): boolean {
-  const dialogs = Array.from(
-    document.querySelectorAll<HTMLElement>('[role="dialog"][aria-modal="true"]')
-  );
-  return dialogs[dialogs.length - 1] === dialog;
-}

src/admin/RequireAuth.tsx

@@ -8,7 +8,11 @@ export function RequireAuth({ children }: { children: ReactNode }) {
   const location = useLocation();
 
   if (status === "loading") {
-    return null;
+    return (
+      <div className="admin-loading-screen">
+        加载中...
+      </div>
+    );
   }
 
   if (status === "guest") {

src/admin/TagsPage.tsx

@@ -2,26 +2,18 @@ import { useEffect, useMemo, useState } from "react";
 import { CheckSquare, Film, Plus, RefreshCw, Search, Tags, Trash2 } from "lucide-react";
 import * as api from "./api";
 import { useToast } from "./ToastContext";
-import { ConfirmModal } from "./ConfirmModal";
 
 const DESKTOP_TAGS_PAGE_SIZE = 25;
 const MOBILE_TAGS_PAGE_SIZE = 8;
 const TAGS_MOBILE_QUERY = "(max-width: 640px)";
 
-type DeleteConfirmState =
-  | { kind: "single"; tag: api.AdminTag }
-  | { kind: "bulk"; ids: number[] }
-  | null;
-
 export function TagsPage() {
   const [tags, setTags] = useState<api.AdminTag[]>([]);
   const [label, setLabel] = useState("");
   const [aliases, setAliases] = useState("");
   const [loading, setLoading] = useState(true);
-  const [loadError, setLoadError] = useState("");
   const [saving, setSaving] = useState(false);
   const [deletingId, setDeletingId] = useState<number | null>(null);
-  const [deleteConfirm, setDeleteConfirm] = useState<DeleteConfirmState>(null);
   const [searchQuery, setSearchQuery] = useState("");
   const [filterSource, setFilterSource] = useState<string>("all");
   const [selectMode, setSelectMode] = useState(false);
@@ -33,13 +25,10 @@ export function TagsPage() {
 
   async function refresh() {
     setLoading(true);
-    setLoadError("");
     try {
       setTags(await api.listTags());
     } catch (e) {
-      const message = e instanceof Error ? e.message : "加载标签失败";
-      setLoadError(message);
-      show(message, "error");
+      show(e instanceof Error ? e.message : "加载标签失败", "error");
     } finally {
       setLoading(false);
     }
@@ -66,9 +55,21 @@ export function TagsPage() {
     }
   }
 
-  function handleDelete(tag: api.AdminTag) {
+  async function handleDelete(tag: api.AdminTag) {
     if (tag.source === "system") return;
-    setDeleteConfirm({ kind: "single", tag });
+    if (!window.confirm(`确定删除标签「${tag.label}」吗？此操作会从所有视频上移除该标签。`)) {
+      return;
+    }
+    setDeletingId(tag.id);
+    try {
+      const r = await api.deleteTag(tag.id);
+      show(`已删除标签，并从 ${r.removedVideos} 个视频移除`, "success");
+      await refresh();
+    } catch (e) {
+      show(e instanceof Error ? e.message : "删除标签失败", "error");
+    } finally {
+      setDeletingId(null);
+    }
   }
 
   function toggleSelectMode() {
@@ -87,40 +88,24 @@ export function TagsPage() {
   async function handleBulkDelete() {
     const ids = [...selected];
     if (ids.length === 0) return;
-    setDeleteConfirm({ kind: "bulk", ids });
-  }
-
-  async function confirmDelete() {
-    if (!deleteConfirm) return;
-
-    if (deleteConfirm.kind === "single") {
-      const tag = deleteConfirm.tag;
-      setDeletingId(tag.id);
-      try {
-        const r = await api.deleteTag(tag.id);
-        show(`已删除标签，并从 ${r.removedVideos} 个视频移除`, "success");
-        setDeleteConfirm(null);
-        await refresh();
-      } catch (e) {
-        show(e instanceof Error ? e.message : "删除标签失败", "error");
-      } finally {
-        setDeletingId(null);
-      }
+    if (!window.confirm(`确定删除选中的 ${ids.length} 个标签吗？此操作会从所有视频上移除这些标签。`)) {
       return;
     }
-
-    const ids = deleteConfirm.ids;
     setBulkDeleting(true);
     try {
-      const results = await Promise.allSettled(
-        ids.map((id) => api.deleteTag(id))
-      );
-      const ok = results.filter((r) => r.status === "fulfilled").length;
+      let ok = 0;
+      for (const id of ids) {
+        try {
+          await api.deleteTag(id);
+          ok += 1;
+        } catch {
+          /* 统计失败数，继续删除其余标签 */
+        }
+      }
       const failed = ids.length - ok;
       show(failed ? `已删除 ${ok} 个，${failed} 个失败` : `已删除 ${ok} 个标签`, failed ? "error" : "success");
       setSelected(new Set());
       setSelectMode(false);
-      setDeleteConfirm(null);
       await refresh();
     } finally {
       setBulkDeleting(false);
@@ -203,7 +188,7 @@ export function TagsPage() {
     <section>
       <header className="admin-page__header">
         <h1 className="admin-page__title">标签管理</h1>
-        <button type="button" className="admin-btn" onClick={refresh}>
+        <button className="admin-btn" onClick={refresh}>
           <RefreshCw size={13} /> 刷新
         </button>
       </header>
@@ -215,39 +200,34 @@ export function TagsPage() {
             <div className="admin-card__title">
               <Plus size={15} /> 新增分类标签
             </div>
-            <form
-              className="admin-form"
-              onSubmit={(e) => {
-                e.preventDefault();
-                handleCreate();
-              }}
-            >
+            <div className="admin-form">
               <div className="admin-form__row">
-                <label htmlFor="admin-tag-label">标签名</label>
+                <label>标签名</label>
                 <input
-                  id="admin-tag-label"
                   value={label}
                   onChange={(e) => setLabel(e.target.value)}
                   placeholder="例如：清纯"
                 />
               </div>
               <div className="admin-form__row">
-                <label htmlFor="admin-tag-aliases">别名</label>
+                <label>别名</label>
                 <input
-                  id="admin-tag-aliases"
                   value={aliases}
                   onChange={(e) => setAliases(e.target.value)}
                   placeholder="逗号分隔，例如：纯欲, 清新"
                 />
+                <div className="admin-form__help">
+                  新增后会按别名和标签名匹配已有视频的标题、作者和目录并自动归类。
+                </div>
               </div>
               <button
-                type="submit"
                 className="admin-btn is-primary"
+                onClick={handleCreate}
                 disabled={saving || !label.trim()}
               >
                 <Plus size={13} /> {saving ? "添加中..." : "添加并自动归类"}
               </button>
-            </form>
+            </div>
           </div>
 
           <div className="admin-card">
@@ -273,7 +253,6 @@ export function TagsPage() {
             <div className="admin-tags-search">
               <Search className="admin-tags-search__icon" size={14} />
               <input
-                aria-label="搜索标签名或别名"
                 type="text"
                 value={searchQuery}
                 onChange={(e) => setSearchQuery(e.target.value)}
@@ -357,18 +336,7 @@ export function TagsPage() {
           )}
 
           {loading ? (
-            <div className="admin-loading-state">
-              <RefreshCw size={20} className="admin-spin" />
-              <span>加载中...</span>
-            </div>
-          ) : loadError ? (
-            <div className="admin-error-state">
-              <strong>标签加载失败</strong>
-              <span>{loadError}</span>
-              <button type="button" className="admin-btn" onClick={refresh}>
-                <RefreshCw size={13} /> 重试
-              </button>
-            </div>
+            <div className="admin-empty">加载中...</div>
           ) : filteredTags.length === 0 ? (
             <div className="admin-card admin-empty">
               没有找到匹配的标签。
@@ -379,18 +347,21 @@ export function TagsPage() {
                 {pagedTags.map((tag) => {
                   const selectable = selectMode && tag.source !== "system";
                   const isSelected = selected.has(tag.id);
-                  const cardClass = `admin-tag-card${selectable ? " is-selectable" : ""}${
-                    selectable && isSelected ? " is-selected" : ""
-                  }`;
-                  const cardContent = (
-                    <>
+                  return (
+                    <div
+                      key={tag.id}
+                      className={`admin-tag-card${selectable ? " is-selectable" : ""}${
+                        selectable && isSelected ? " is-selected" : ""
+                      }`}
+                      onClick={selectable ? () => toggleSelect(tag.id) : undefined}
+                    >
                       <div className="admin-tag-card__head">
                         {selectable && (
                           <input
                             type="checkbox"
                             className="admin-tag-card__check"
                             checked={isSelected}
-                            onChange={() => toggleSelect(tag.id)}
+                            readOnly
                           />
                         )}
                         <span className="admin-tag-card__title">{tag.label}</span>
@@ -409,7 +380,7 @@ export function TagsPage() {
                         </div>
                       )}
 
-	                      <div className="admin-tag-card__footer">
+                      <div className="admin-tag-card__footer">
                         <span className="admin-tag-card__count">
                           <Film size={13} />
                           <strong>{tag.count}</strong> 视频
@@ -428,17 +399,8 @@ export function TagsPage() {
                               <span>{deletingId === tag.id ? "删除中" : "删除"}</span>
                             </button>
                           )}
-	                        </div>
-	                      </div>
-	                    </>
-	                  );
-                  return selectable ? (
-                    <label key={tag.id} className={cardClass}>
-                      {cardContent}
-                    </label>
-                  ) : (
-                    <div key={tag.id} className={cardClass}>
-                      {cardContent}
+                        </div>
+                      </div>
                     </div>
                   );
                 })}
@@ -487,24 +449,6 @@ export function TagsPage() {
           )}
         </div>
       </div>
-      <ConfirmModal
-        open={!!deleteConfirm}
-        title={deleteConfirm?.kind === "bulk" ? "删除选中标签" : "删除标签"}
-        message={
-          deleteConfirm?.kind === "bulk"
-            ? `确定要删除选中的 ${deleteConfirm.ids.length} 个标签吗？`
-            : `确定要删除标签「${deleteConfirm?.tag.label ?? ""}」吗？`
-        }
-        confirmText="确认删除"
-        danger
-        centerMessage
-        modalClassName="admin-modal--delete-confirm"
-        loading={deletingId !== null || bulkDeleting}
-        onCancel={() => {
-          if (deletingId === null && !bulkDeleting) setDeleteConfirm(null);
-        }}
-        onConfirm={confirmDelete}
-      />
     </section>
   );
 }

src/admin/ThemePage.tsx

@@ -103,6 +103,9 @@ export function ThemePage() {
     <div className="theme-page">
       <header className="theme-page__head">
         <h1 className="theme-page__title">主题外观</h1>
+        <p className="theme-page__sub">
+          切换全站主题。所有访客都会看到这里选定的主题，本设置会写入数据库永久保存。
+        </p>
       </header>
 
       <div className="theme-grid">

src/admin/ToastContext.tsx

@@ -43,13 +43,11 @@ export function ToastProvider({ children }: { children: ReactNode }) {
   return (
     <ToastCtx.Provider value={{ show }}>
       {children}
-      <div className="admin-toast-stack" role="status" aria-live="polite">
-        {items.map((t) => (
-          <div key={t.id} className={`admin-toast is-${t.kind}`}>
-            {t.text}
-          </div>
-        ))}
-      </div>
+      {items.map((t) => (
+        <div key={t.id} className={`admin-toast is-${t.kind}`}>
+          {t.text}
+        </div>
+      ))}
     </ToastCtx.Provider>
   );
 }

src/admin/VideosPage.tsx

@@ -1,43 +1,28 @@
-import { useEffect, useId, useState } from "react";
-import { ChevronDown, Edit, RefreshCw, Search, CheckSquare, Square, Image, Trash2 } from "lucide-react";
+import { useEffect, useState } from "react";
+import { Edit, RefreshCw, Search } from "lucide-react";
 import * as api from "./api";
 import { useToast } from "./ToastContext";
 import { Modal } from "./Modal";
-import { ConfirmModal } from "./ConfirmModal";
-import { formatBytes } from "./storageFormat";
 
-const DESKTOP_VIDEOS_PAGE_SIZE = 50;
-const MOBILE_VIDEOS_PAGE_SIZE = 20;
-const VIDEOS_MOBILE_QUERY = "(max-width: 640px)";
+const PAGE_SIZE = 100;
 
 export function VideosPage() {
   const [list, setList] = useState<api.AdminVideo[]>([]);
   const [drives, setDrives] = useState<api.AdminDrive[]>([]);
   const [loading, setLoading] = useState(true);
-  const [loadError, setLoadError] = useState("");
   const [keyword, setKeyword] = useState("");
-  const [searchKeyword, setSearchKeyword] = useState("");
   const [driveId, setDriveId] = useState("");
   const [page, setPage] = useState(1);
   const [total, setTotal] = useState(0);
   const [editing, setEditing] = useState<api.AdminVideo | null>(null);
   const [availableTags, setAvailableTags] = useState<api.AdminTag[]>([]);
-  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
-  const [batchRegenOpen, setBatchRegenOpen] = useState(false);
-  const [batchRegening, setBatchRegening] = useState(false);
-  const [batchDeleteOpen, setBatchDeleteOpen] = useState(false);
-  const [batchDeleting, setBatchDeleting] = useState(false);
-  const [deleteTarget, setDeleteTarget] = useState<api.AdminVideo | null>(null);
-  const [deleting, setDeleting] = useState(false);
-  const pageSize = useVideosPageSize();
   const { show } = useToast();
 
   async function refresh() {
     setLoading(true);
-    setLoadError("");
     try {
       const [r, tagList, driveList] = await Promise.all([
-        api.listVideos({ driveId, page, size: pageSize, keyword: searchKeyword }),
+        api.listVideos({ driveId, page, size: PAGE_SIZE }),
         api.listTags(),
         api.listDrives(),
       ]);
@@ -45,11 +30,8 @@ export function VideosPage() {
       setTotal(r.total ?? 0);
       setAvailableTags(tagList);
       setDrives(driveList ?? []);
-      setSelectedIds(new Set());
     } catch (e) {
-      const message = e instanceof Error ? e.message : "加载失败";
-      setLoadError(message);
-      show(message, "error");
+      show(e instanceof Error ? e.message : "加载失败", "error");
     } finally {
       setLoading(false);
     }
@@ -57,270 +39,133 @@ export function VideosPage() {
 
   useEffect(() => {
     refresh();
-  }, [driveId, page, searchKeyword, pageSize]);
-
-  useEffect(() => {
-    setPage(1);
-  }, [pageSize]);
-
-  useEffect(() => {
-    if (keyword === searchKeyword) return;
-    const timer = window.setTimeout(() => {
-      setSearchKeyword(keyword);
-      setPage(1);
-    }, 300);
-    return () => window.clearTimeout(timer);
-  }, [keyword]);
+  }, [driveId, page]);
 
   const driveNameMap = new Map(
     drives.map((d) => [d.id, d.name || d.id])
   );
 
-  const listItems = list;
-  const totalPages = Math.max(1, Math.ceil(total / pageSize));
-  const pageStart = total === 0 ? 0 : (page - 1) * pageSize + 1;
-  const pageEnd = Math.min(total, page * pageSize);
-  const listSummary = driveId
-    ? `${driveNameMap.get(driveId) ?? driveId}：共 ${total} 个视频，第 ${page} / ${totalPages} 页，显示 ${pageStart}-${pageEnd}`
-    : `全部网盘：共 ${total} 个视频，第 ${page} / ${totalPages} 页，显示 ${pageStart}-${pageEnd}`;
+  const filtered = keyword.trim()
+    ? list.filter((v) => {
+        const k = keyword.toLowerCase();
+        return (
+          v.title.toLowerCase().includes(k) ||
+          (v.author ?? "").toLowerCase().includes(k)
+        );
+      })
+    : list;
+  const totalPages = Math.max(1, Math.ceil(total / PAGE_SIZE));
+  const pageStart = total === 0 ? 0 : (page - 1) * PAGE_SIZE + 1;
+  const pageEnd = Math.min(total, page * PAGE_SIZE);
 
   async function handleRegen(v: api.AdminVideo) {
     try {
       await api.regenPreview(v.id);
-      show("已触发预览视频重生", "success");
+      show("已触发 teaser 重生", "success");
     } catch (e) {
       show(e instanceof Error ? e.message : "触发失败", "error");
     }
   }
 
-  async function handleBatchRegen() {
-    if (selectedIds.size === 0) return;
-    setBatchRegenOpen(true);
-  }
-
-  async function handleBatchDelete() {
-    if (selectedIds.size === 0) return;
-    setBatchDeleteOpen(true);
-  }
-
-  async function confirmBatchRegen() {
-    const ids = [...selectedIds];
-    setBatchRegening(true);
-    let success = 0;
-    try {
-      const results = await Promise.allSettled(
-        ids.map((id) => api.regenPreview(id))
-      );
-      for (const r of results) {
-        if (r.status === "fulfilled") success++;
-      }
-      show(`批量触发完成，成功 ${success} / ${ids.length} 个`, success === ids.length ? "success" : "info");
-      setSelectedIds(new Set());
-      setBatchRegenOpen(false);
-    } finally {
-      setBatchRegening(false);
-    }
-  }
-
-  async function confirmDeleteVideo() {
-    if (!deleteTarget) return;
-    const target = deleteTarget;
-    setDeleting(true);
-    try {
-      const result = await api.deleteVideo(target.id);
-      setDeleteTarget(null);
-      setSelectedIds((ids) => {
-        const next = new Set(ids);
-        next.delete(target.id);
-        return next;
-      });
-      show(result.deletedSource ? "已删除视频，并清理 91Spider 源文件" : "已删除视频", "success");
-      if (listItems.length === 1 && page > 1) {
-        setPage((p) => Math.max(1, p - 1));
-      } else {
-        refresh();
-      }
-    } catch (e) {
-      show(e instanceof Error ? e.message : "删除失败", "error");
-    } finally {
-      setDeleting(false);
-    }
-  }
-
-  async function confirmBatchDelete() {
-    const ids = [...selectedIds];
-    if (ids.length === 0) return;
-    setBatchDeleting(true);
-    try {
-      const results = await Promise.allSettled(
-        ids.map((id) => api.deleteVideo(id))
-      );
-      let success = 0;
-      let deletedSources = 0;
-      for (const r of results) {
-        if (r.status !== "fulfilled") continue;
-        success++;
-        if (r.value.deletedSource) deletedSources++;
-      }
-      const failed = ids.length - success;
-      if (failed === 0) {
-        const extra = deletedSources > 0 ? `，其中 ${deletedSources} 个清理了 91Spider 源文件` : "";
-        show(`批量删除完成，成功 ${success} 个${extra}`, "success");
-      } else {
-        show(`批量删除完成，成功 ${success} / ${ids.length} 个，失败 ${failed} 个`, success > 0 ? "info" : "error");
-      }
-      setSelectedIds(new Set());
-      setBatchDeleteOpen(false);
-      if (success >= listItems.length && page > 1) {
-        setPage((p) => Math.max(1, p - 1));
-      } else {
-        refresh();
-      }
-    } finally {
-      setBatchDeleting(false);
-    }
-  }
-
-  const toggleSelectAll = () => {
-    if (selectedIds.size === listItems.length && listItems.length > 0) {
-      setSelectedIds(new Set());
-    } else {
-      setSelectedIds(new Set(listItems.map(v => v.id)));
-    }
-  };
-
-  const toggleSelect = (id: string) => {
-    const next = new Set(selectedIds);
-    if (next.has(id)) next.delete(id);
-    else next.add(id);
-    setSelectedIds(next);
-  };
-
-  function handleSearchSubmit(e: React.FormEvent) {
-    e.preventDefault();
-    setSearchKeyword(keyword);
-    setPage(1);
-  }
-
   return (
     <section>
       <header className="admin-page__header">
         <h1 className="admin-page__title">视频管理</h1>
         <div className="admin-page__actions admin-videos-filter">
-          <div className="admin-videos-filter__select-wrap">
-            <select
-              className="admin-videos-filter__select"
-              value={driveId}
-              onChange={(e) => {
-                setDriveId(e.target.value);
-                setPage(1);
-              }}
-            >
-              <option value="">全部网盘</option>
-              {drives.map((d) => (
-                <option key={d.id} value={d.id}>
-                  {d.name || d.id}（已生成 {d.teaserReadyCount ?? 0}，待生成{" "}
-                  {d.teaserPendingCount ?? 0}）
-                </option>
-              ))}
-            </select>
-            <ChevronDown size={15} className="admin-videos-filter__select-icon" aria-hidden="true" />
-          </div>
-          <form className="admin-videos-filter__search" onSubmit={handleSearchSubmit}>
+          <select
+            className="admin-videos-filter__select"
+            value={driveId}
+            onChange={(e) => {
+              setDriveId(e.target.value);
+              setPage(1);
+            }}
+          >
+            <option value="">全部网盘</option>
+            {drives.map((d) => (
+              <option key={d.id} value={d.id}>
+                {d.name || d.id}（已生成 {d.teaserReadyCount ?? 0}，待生成{" "}
+                {d.teaserPendingCount ?? 0}）
+              </option>
+            ))}
+          </select>
+          <div className="admin-videos-filter__search">
             <Search size={14} className="admin-videos-filter__search-icon" />
             <input
-              aria-label="搜索标题或作者"
               value={keyword}
               onChange={(e) => setKeyword(e.target.value)}
               placeholder="搜索标题 / 作者"
             />
-          </form>
-          <button type="button" className="admin-btn" onClick={refresh}>
+          </div>
+          <button className="admin-btn" onClick={refresh}>
             <RefreshCw size={13} /> 刷新
           </button>
         </div>
       </header>
 
-      {!loading && (
-        <div className="admin-videos-list-toolbar">
-          <div className="admin-videos-summary">{listSummary}</div>
-          {selectedIds.size > 0 && (
-            <div className="admin-videos-bulk-actions">
-              <span className="admin-videos-bulk-actions__count">
-                已选择 {selectedIds.size} 项
+      {drives.length > 0 && (
+        <div className="admin-drive-teasers" aria-label="网盘 Teaser 统计">
+          {drives.map((d) => (
+            <button
+              key={d.id}
+              type="button"
+              className={`admin-drive-teaser${
+                driveId === d.id ? " is-active" : ""
+              }`}
+              onClick={() => {
+                setDriveId(d.id);
+                setPage(1);
+              }}
+            >
+              <span className="admin-drive-teaser__name">{d.name || d.id}</span>
+              <span className="admin-drive-teaser__metric is-ready">
+                已生成 {d.teaserReadyCount ?? 0}
               </span>
-              <button type="button" className="admin-btn is-primary admin-videos-bulk-actions__btn" onClick={handleBatchRegen}>
-                <RefreshCw size={13} /> 批量重生预览视频
-              </button>
-              <button type="button" className="admin-btn is-danger admin-videos-bulk-actions__btn" onClick={handleBatchDelete}>
-                <Trash2 size={13} /> 批量删除
-              </button>
-            </div>
-          )}
+              <span className="admin-drive-teaser__metric is-pending">
+                待生成 {d.teaserPendingCount ?? 0}
+              </span>
+              {(d.teaserFailedCount ?? 0) > 0 && (
+                <span className="admin-drive-teaser__metric is-failed">
+                  失败 {d.teaserFailedCount}
+                </span>
+              )}
+            </button>
+          ))}
+        </div>
+      )}
+
+      {!loading && (
+        <div className="admin-videos-summary">
+          {driveId
+            ? `${driveNameMap.get(driveId) ?? driveId}：共 ${total} 个视频，第 ${page} / ${totalPages} 页，显示 ${pageStart}-${pageEnd}`
+            : `全部网盘：共 ${total} 个视频，第 ${page} / ${totalPages} 页，显示 ${pageStart}-${pageEnd}`}
         </div>
       )}
 
       {loading ? (
-        <div className="admin-loading-state">
-          <RefreshCw size={20} className="admin-spin" />
-          <span>加载中...</span>
-        </div>
-      ) : loadError ? (
-        <div className="admin-error-state">
-          <strong>视频加载失败</strong>
-          <span>{loadError}</span>
-          <button type="button" className="admin-btn" onClick={refresh}>
-            <RefreshCw size={13} /> 重试
-          </button>
-        </div>
-      ) : listItems.length === 0 ? (
-        <div className="admin-empty-state">
-          <div className="admin-empty-state__icon">
-            <Image size={48} />
-          </div>
-          <div className="admin-empty-state__text">
-            {driveId
-              ? "这个网盘下还没有可显示的视频，或未匹配到搜索结果。"
-              : "还没有视频。先在「网盘管理」里配置好盘并触发扫描，或调整搜索词。"}
-          </div>
+        <div className="admin-empty">加载中...</div>
+      ) : filtered.length === 0 ? (
+        <div className="admin-card admin-empty">
+          {driveId
+            ? "这个网盘下还没有可显示的视频。可以在「网盘管理」里触发重扫。"
+            : "还没有视频。先在「网盘管理」里配置好盘并触发扫描。"}
         </div>
       ) : (
         <>
-          <table className="admin-table is-selectable admin-videos-table">
+          <table className="admin-table">
             <thead>
               <tr>
-                <th className="is-checkbox" style={{ width: '40px' }}>
-                  <button
-                    type="button"
-                    className="admin-table-checkbox-btn"
-                    onClick={toggleSelectAll}
-                    aria-label={selectedIds.size > 0 && selectedIds.size === listItems.length ? "清空当前页选择" : "选择当前页视频"}
-                  >
-                    {selectedIds.size > 0 && selectedIds.size === listItems.length ? <CheckSquare size={16} /> : <Square size={16} />}
-                  </button>
-                </th>
                 <th>标题</th>
                 <th>作者</th>
                 <th>标签</th>
                 <th>时长</th>
-                <th>预览视频</th>
+                <th>Teaser</th>
                 <th>来源</th>
                 <th className="is-actions">操作</th>
               </tr>
             </thead>
             <tbody>
-              {listItems.map((v) => (
-                <tr key={v.id} className={selectedIds.has(v.id) ? "is-selected" : ""}>
-                  <td className="is-checkbox">
-                    <button
-                      type="button"
-                      className="admin-table-checkbox-btn"
-                      onClick={() => toggleSelect(v.id)}
-                      aria-label={`${selectedIds.has(v.id) ? "取消选择" : "选择"}视频 ${v.title}`}
-                    >
-                      {selectedIds.has(v.id) ? <CheckSquare size={16} color="var(--accent)" /> : <Square size={16} color="var(--border-strong)" />}
-                    </button>
-                  </td>
+              {filtered.map((v) => (
+                <tr key={v.id}>
                   <td data-label="标题">
                     <div className="admin-video-title">{v.title}</div>
                     {fileMeta(v) && (
@@ -328,7 +173,6 @@ export function VideosPage() {
                         {fileMeta(v)}
                       </div>
                     )}
-                    <VideoFileMetaPills video={v} />
                   </td>
                   <td data-label="作者">{v.author || <span className="admin-text-faint">—</span>}</td>
                   <td data-label="标签">
@@ -341,21 +185,18 @@ export function VideosPage() {
                     </div>
                   </td>
                   <td data-label="时长">{formatDur(v.durationSeconds)}</td>
-                  <td data-label="预览视频">
+                  <td data-label="Teaser">
                     <PreviewStatus s={v.previewStatus} />
                   </td>
                   <td data-label="来源" className="admin-mono-cell">
                     {driveNameMap.get(v.driveId) ?? v.driveId}
                   </td>
                   <td className="is-actions" data-label="操作">
-                    <button type="button" className="admin-btn" onClick={() => setEditing(v)}>
+                    <button className="admin-btn" onClick={() => setEditing(v)}>
                       <Edit size={13} /> 编辑
                     </button>{" "}
-                    <button type="button" className="admin-btn" onClick={() => handleRegen(v)} title="重生预览视频">
-                      <RefreshCw size={13} />
-                    </button>{" "}
-                    <button type="button" className="admin-btn is-danger" onClick={() => setDeleteTarget(v)} title="删除视频">
-                      <Trash2 size={13} />
+                    <button className="admin-btn" onClick={() => handleRegen(v)}>
+                      <RefreshCw size={13} /> 重生 teaser
                     </button>
                   </td>
                 </tr>
@@ -364,7 +205,6 @@ export function VideosPage() {
           </table>
           <div className="admin-table-pagination">
             <button
-              type="button"
               className="admin-btn"
               onClick={() => setPage(1)}
               disabled={page <= 1}
@@ -372,7 +212,6 @@ export function VideosPage() {
               首页
             </button>
             <button
-              type="button"
               className="admin-btn"
               onClick={() => setPage((p) => Math.max(1, p - 1))}
               disabled={page <= 1}
@@ -380,10 +219,9 @@ export function VideosPage() {
               上一页
             </button>
             <span className="admin-table-pagination__info">
-              第 {page} / {totalPages} 页，每页 {pageSize} 个
+              第 {page} / {totalPages} 页，每页 {PAGE_SIZE} 个
             </span>
             <button
-              type="button"
               className="admin-btn"
               onClick={() => setPage((p) => Math.min(totalPages, p + 1))}
               disabled={page >= totalPages}
@@ -391,7 +229,6 @@ export function VideosPage() {
               下一页
             </button>
             <button
-              type="button"
               className="admin-btn"
               onClick={() => setPage(totalPages)}
               disabled={page >= totalPages}
@@ -413,45 +250,6 @@ export function VideosPage() {
           }}
         />
       )}
-      <ConfirmModal
-        open={batchRegenOpen}
-        title="批量重生预览视频"
-        message={`确定要为当前页选中的 ${selectedIds.size} 个视频重新生成预览视频吗？`}
-        confirmText="确认重生"
-        loading={batchRegening}
-        onCancel={() => {
-          if (!batchRegening) setBatchRegenOpen(false);
-        }}
-        onConfirm={confirmBatchRegen}
-      />
-      <ConfirmModal
-        open={deleteTarget !== null}
-        title="删除视频"
-        message={deleteTarget ? `确定要删除「${deleteTarget.title}」吗？` : ""}
-        confirmText="删除视频"
-        danger
-        centerMessage
-        modalClassName="admin-modal--delete-confirm"
-        loading={deleting}
-        onCancel={() => {
-          if (!deleting) setDeleteTarget(null);
-        }}
-        onConfirm={confirmDeleteVideo}
-      />
-      <ConfirmModal
-        open={batchDeleteOpen}
-        title="批量删除视频"
-        message={`确定要删除当前页选中的 ${selectedIds.size} 个视频吗？`}
-        confirmText="批量删除"
-        danger
-        centerMessage
-        modalClassName="admin-modal--delete-confirm"
-        loading={batchDeleting}
-        onCancel={() => {
-          if (!batchDeleting) setBatchDeleteOpen(false);
-        }}
-        onConfirm={confirmBatchDelete}
-      />
     </section>
   );
 }
@@ -463,27 +261,6 @@ function PreviewStatus({ s }: { s: string }) {
   return <span className="admin-status is-pending">待生成</span>;
 }
 
-function VideoFileMetaPills({ video }: { video: api.AdminVideo }) {
-  const parts = fileMetaParts(video);
-  const category = (video.category ?? "").trim();
-  if (parts.length === 0 && !category) return null;
-
-  return (
-    <div className="admin-video-filemeta-pills" aria-label="视频文件信息">
-      {parts.map((part, index) => (
-        <span key={`${part}-${index}`} className="admin-video-filemeta-pill">
-          {part}
-        </span>
-      ))}
-      {category && (
-        <span className="admin-video-filemeta-pill is-category">
-          {category}
-        </span>
-      )}
-    </div>
-  );
-}
-
 function formatDur(sec: number): string {
   if (!sec) return "—";
   const m = Math.floor(sec / 60);
@@ -491,26 +268,6 @@ function formatDur(sec: number): string {
   return `${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}`;
 }
 
-function useVideosPageSize() {
-  const [pageSize, setPageSize] = useState(() =>
-    window.matchMedia(VIDEOS_MOBILE_QUERY).matches
-      ? MOBILE_VIDEOS_PAGE_SIZE
-      : DESKTOP_VIDEOS_PAGE_SIZE
-  );
-
-  useEffect(() => {
-    const media = window.matchMedia(VIDEOS_MOBILE_QUERY);
-    const update = () => {
-      setPageSize(media.matches ? MOBILE_VIDEOS_PAGE_SIZE : DESKTOP_VIDEOS_PAGE_SIZE);
-    };
-    update();
-    media.addEventListener("change", update);
-    return () => media.removeEventListener("change", update);
-  }, []);
-
-  return pageSize;
-}
-
 function EditVideoModal({
   video,
   availableTags,
@@ -522,7 +279,6 @@ function EditVideoModal({
   onClose: () => void;
   onSaved: () => void;
 }) {
-  const idPrefix = useId();
   const [title, setTitle] = useState(video.title);
   const [author, setAuthor] = useState(video.author ?? "");
   const [selectedTags, setSelectedTags] = useState(video.tags ?? []);
@@ -565,10 +321,10 @@ function EditVideoModal({
       onClose={onClose}
       footer={
         <>
-          <button type="button" className="admin-btn" onClick={onClose}>
+          <button className="admin-btn" onClick={onClose}>
             取消
           </button>
-          <button type="button" className="admin-btn is-primary" onClick={handleSave} disabled={saving}>
+          <button className="admin-btn is-primary" onClick={handleSave} disabled={saving}>
             {saving ? "保存中..." : "保存"}
           </button>
         </>
@@ -576,15 +332,15 @@ function EditVideoModal({
     >
       <div className="admin-form">
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-title`}>标题</label>
-          <input id={`${idPrefix}-video-title`} value={title} onChange={(e) => setTitle(e.target.value)} />
+          <label>标题</label>
+          <input value={title} onChange={(e) => setTitle(e.target.value)} />
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-author`}>作者</label>
-          <input id={`${idPrefix}-video-author`} value={author} onChange={(e) => setAuthor(e.target.value)} />
+          <label>作者</label>
+          <input value={author} onChange={(e) => setAuthor(e.target.value)} />
         </div>
         <div className="admin-form__row">
-          <div className="admin-form__label">标签</div>
+          <label>标签</label>
           <div className="admin-tag-picker">
             {availableTags.map((tag) => (
               <label key={tag.id} className="admin-check">
@@ -600,49 +356,36 @@ function EditVideoModal({
           </div>
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-category`}>分类</label>
-          <input id={`${idPrefix}-video-category`} value={category} onChange={(e) => setCategory(e.target.value)} />
+          <label>分类</label>
+          <input value={category} onChange={(e) => setCategory(e.target.value)} />
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-badges`}>徽标（逗号分隔，例如 精选, 原创）</label>
-          <input id={`${idPrefix}-video-badges`} value={badges} onChange={(e) => setBadges(e.target.value)} />
+          <label>徽标（逗号分隔，例如 精选, 原创）</label>
+          <input value={badges} onChange={(e) => setBadges(e.target.value)} />
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-quality`}>质量</label>
-          <select id={`${idPrefix}-video-quality`} value={quality} onChange={(e) => setQuality(e.target.value)}>
+          <label>质量</label>
+          <select value={quality} onChange={(e) => setQuality(e.target.value)}>
             <option value="">未设置</option>
             <option value="HD">HD</option>
             <option value="SD">SD</option>
           </select>
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-duration`}>时长（秒）</label>
+          <label>时长（秒）</label>
           <input
-            id={`${idPrefix}-video-duration`}
             value={durationSec}
             onChange={(e) => setDurationSec(e.target.value)}
             inputMode="numeric"
           />
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-thumbnail`}>封面 URL</label>
-          <div className="admin-thumbnail-preview">
-            <input id={`${idPrefix}-video-thumbnail`} value={thumbnail} onChange={(e) => setThumbnail(e.target.value)} />
-            {thumbnail && (
-              <img 
-                src={thumbnail} 
-                alt="封面预览" 
-                className="admin-thumbnail-img" 
-                onError={(e) => (e.currentTarget.style.display = 'none')} 
-                onLoad={(e) => (e.currentTarget.style.display = 'block')} 
-              />
-            )}
-          </div>
+          <label>封面 URL</label>
+          <input value={thumbnail} onChange={(e) => setThumbnail(e.target.value)} />
         </div>
         <div className="admin-form__row">
-          <label htmlFor={`${idPrefix}-video-description`}>描述</label>
+          <label>描述</label>
           <textarea
-            id={`${idPrefix}-video-description`}
             value={description}
             onChange={(e) => setDescription(e.target.value)}
           />
@@ -652,7 +395,7 @@ function EditVideoModal({
           <dd>{video.driveId}</dd>
           <dt>文件信息</dt>
           <dd>{fileMeta(video) || "—"}</dd>
-          <dt>预览视频</dt>
+          <dt>Teaser</dt>
           <dd>
             <PreviewStatus s={video.previewStatus} />
           </dd>
@@ -672,15 +415,12 @@ function EditVideoModal({
 }
 
 function fileMeta(v: api.AdminVideo): string {
-  return fileMetaParts(v).join(" · ");
-}
-
-function fileMetaParts(v: api.AdminVideo): string[] {
-  return [
+  const parts = [
     normalizeExt(v.ext),
     v.quality,
-    v.size > 0 ? formatBytes(v.size) : "",
+    formatBytes(v.size),
   ].filter(Boolean);
+  return parts.join(" · ");
 }
 
 function normalizeExt(ext: string): string {
@@ -688,6 +428,19 @@ function normalizeExt(ext: string): string {
   return value ? value.toUpperCase() : "";
 }
 
+function formatBytes(size: number): string {
+  if (!size || size <= 0) return "";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = size;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  const digits = unit === 0 || value >= 100 ? 0 : 1;
+  return `${value.toFixed(digits)} ${units[unit]}`;
+}
+
 function splitList(s: string): string[] {
   return s
     .split(/[,，、\s]+/)

src/admin/api.ts

@@ -83,7 +83,7 @@ export type AdminDrive = {
   status: string;
   lastError?: string;
   hasCredential: boolean;
-  /** 当前是否给该盘生成预览视频/封面（per-drive 开关，替代旧的全局 preview.enabled）。 */
+  /** 当前是否给该盘生成 teaser/封面（per-drive 开关，替代旧的全局 preview.enabled）。 */
   teaserEnabled: boolean;
   /**
    * 用户在 admin 配置的"扫描跳过目录"集合（drive 侧目录 fileID 列表）。
@@ -176,13 +176,6 @@ export function rescan(id: string) {
   );
 }
 
-export function stopDriveTasks(id: string) {
-  return request<{ ok: boolean; stopped: boolean }>(
-    `/drives/${encodeURIComponent(id)}/tasks/stop`,
-    { method: "POST" }
-  );
-}
-
 export type P123QRSession = {
   loginUuid: string;
   uniID: string;
@@ -211,9 +204,9 @@ export function getP123QRStatus(uniID: string, loginUuid: string) {
 }
 
 /**
- * 切换某个云盘的预览视频生成开关。点击网盘列表里行内的 toggle 按钮时调用。
+ * 切换某个云盘的 teaser 生成开关。点击网盘列表里行内的 toggle 按钮时调用。
  *
- * 后端会写 catalog.drives.teaser_enabled，并在从关到开时立刻补扫该盘 pending 预览视频；
+ * 后端会写 catalog.drives.teaser_enabled，并在从关到开时立刻补扫该盘 pending teaser；
  * 关闭分支不补做任何事，新的入队判断会自动停。
  */
 export function setDriveTeaserEnabled(id: string, enabled: boolean) {
@@ -272,7 +265,7 @@ export function regenFailedPreviews(id: string) {
 
 /**
  * 触发某 drive 下所有 thumbnail_status=failed 的封面重新入队生成。
- * 与 regenFailedPreviews 行为对称（一个管预览视频，一个管封面）。
+ * 与 regenFailedPreviews 行为对称（一个管 teaser，一个管封面）。
  *
  * 后端立即返回 202；实际状态变化在下次 listDrives 拉到的 thumbnailFailedCount /
  * thumbnailGenerationStatus 字段里观察。
@@ -324,12 +317,11 @@ export type AdminVideoList = {
   size: number;
 };
 
-export function listVideos(params: { driveId?: string; page?: number; size?: number; keyword?: string } = {}) {
+export function listVideos(params: { driveId?: string; page?: number; size?: number } = {}) {
   const qs = new URLSearchParams();
   if (params.driveId) qs.set("driveId", params.driveId);
   if (params.page) qs.set("page", String(params.page));
   if (params.size) qs.set("size", String(params.size));
-  if (params.keyword) qs.set("keyword", params.keyword);
   const suffix = qs.toString() ? `?${qs.toString()}` : "";
   return request<AdminVideoList>(`/videos${suffix}`);
 }
@@ -353,13 +345,6 @@ export function updateVideo(id: string, body: UpdateVideoInput) {
   });
 }
 
-export function deleteVideo(id: string) {
-  return request<{ ok: boolean; deletedSource: boolean }>(
-    `/videos/${encodeURIComponent(id)}`,
-    { method: "DELETE" }
-  );
-}
-
 export function regenPreview(id: string) {
   return request<{ ok: boolean }>(
     `/videos/${encodeURIComponent(id)}/regen-preview`,
@@ -402,9 +387,9 @@ export type Theme = "dark" | "pink";
 export type Settings = {
   theme: Theme;
   /**
-   * spider91 视频迁移到云盘时的目标 drive ID（必须是已挂载的 pikpak、p115、p123 或 onedrive drive）。
+   * spider91 视频迁移到云盘时的目标 drive ID（必须是已挂载的 pikpak、p115 或 onedrive drive）。
    * - 空字符串：本地保存，不上传到云盘。
-   * - 非空：显式指定。后端会校验 drive 存在且 kind ∈ {pikpak, p115, p123, onedrive}。
+   * - 非空：显式指定。后端会校验 drive 存在且 kind ∈ {pikpak, p115, onedrive}。
    */
   spider91UploadDriveId: string;
 };
@@ -453,10 +438,3 @@ export function runNightlyJob() {
     { method: "POST" }
   );
 }
-
-export function stopAllTasks() {
-  return request<{ ok: boolean; stoppedDrives: number; status: NightlyJobStatus }>(
-    "/tasks/stop",
-    { method: "POST" }
-  );
-}

src/admin/drive/DeleteDriveModal.tsx

@@ -1,46 +0,0 @@
-import { Trash2 } from "lucide-react";
-import * as api from "../api";
-import { Modal } from "../Modal";
-
-export function DeleteDriveModal({
-  drive,
-  deleting,
-  onCancel,
-  onConfirm,
-}: {
-  drive: api.AdminDrive | null;
-  deleting: boolean;
-  onCancel: () => void;
-  onConfirm: () => void;
-}) {
-  const name = drive?.name || drive?.id || "";
-  const isSpider91 = drive?.kind === "spider91";
-  const title = isSpider91 ? "删除 91Spider" : "删除存储";
-  const primaryText = deleting ? "删除中..." : "确认删除";
-
-  return (
-    <Modal
-      open={!!drive}
-      title={title}
-      onClose={onCancel}
-      className="admin-modal--delete-confirm"
-      footer={
-        <>
-          <button className="admin-btn" onClick={onCancel} disabled={deleting}>
-            取消
-          </button>
-          <button className="admin-btn is-danger" onClick={onConfirm} disabled={deleting}>
-            <Trash2 size={13} />
-            {primaryText}
-          </button>
-        </>
-      }
-    >
-      <div className="admin-confirm is-message-centered">
-        <div className="admin-confirm__content">
-          <p className="admin-confirm__message">{`确定要删除「${name}」吗？`}</p>
-        </div>
-      </div>
-    </Modal>
-  );
-}

src/admin/drive/DriveComponents.tsx

@@ -1,286 +0,0 @@
-import { PlayCircle, Power, PowerOff, RotateCcw } from "lucide-react";
-import * as api from "../api";
-import { formatBytes } from "../storageFormat";
-import {
-  generationStateLabel,
-  generationStateClass,
-  generationDetail,
-  generationTitle,
-} from "./constants";
-
-export function StorageSummary({ storage }: { storage: api.AdminDriveStorage }) {
-  return (
-    <section className="admin-card admin-storage-summary" aria-label="本地媒体存储">
-      <div className="admin-storage-summary__metric">
-        <span>封面占用</span>
-        <strong>{formatBytes(storage.thumbnailBytes)}</strong>
-      </div>
-      <div className="admin-storage-summary__metric">
-        <span>预览视频占用</span>
-        <strong>{formatBytes(storage.teaserBytes)}</strong>
-      </div>
-      <div className="admin-storage-summary__metric">
-        <span>本地媒体合计</span>
-        <strong>{formatBytes(storage.totalBytes)}</strong>
-      </div>
-      <div className="admin-storage-summary__metric">
-        <span>磁盘可用</span>
-        <strong>{formatBytes(storage.availableBytes)}</strong>
-      </div>
-    </section>
-  );
-}
-
-export function GenerationCounts({
-  ready,
-  pending,
-  failed,
-  durationPending,
-}: {
-  ready?: number;
-  pending?: number;
-  failed?: number;
-  durationPending?: number;
-}) {
-  return (
-    <div className="admin-generation-counts">
-      <span className="admin-drive-teaser__metric is-ready">
-        就绪 {ready ?? 0}
-      </span>
-      <span className="admin-drive-teaser__metric is-pending">
-        待生成 {pending ?? 0}
-      </span>
-      <span className="admin-drive-teaser__metric is-failed">
-        失败 {failed ?? 0}
-      </span>
-      {(durationPending ?? 0) > 0 && (
-        <span className="admin-drive-teaser__metric">
-          待补时长 {durationPending}
-        </span>
-      )}
-    </div>
-  );
-}
-
-export function GenerationStatusLine({
-  label,
-  status,
-}: {
-  label: string;
-  status?: api.DriveGenerationStatus;
-}) {
-  const state = status?.state || "idle";
-  const queueLength = status?.queueLength ?? 0;
-  const detail = generationDetail(status);
-  const title = generationTitle(status, detail);
-  const countText = queueLength > 0 ? `${label === "封面" ? "待处理" : "队列"} ${queueLength}` : "";
-
-  return (
-    <div className="admin-generation-row" title={title}>
-      <span className="admin-generation-kind">{label}</span>
-      <span className={`admin-status admin-generation-state is-${generationStateClass(state)}`}>
-        {generationStateLabel(state)}
-      </span>
-      {(detail || queueLength > 0) && (
-        <span className="admin-generation-detail">
-          {[detail, countText].filter(Boolean).join(" / ")}
-        </span>
-      )}
-    </div>
-  );
-}
-
-export function StatusTag({
-  kind,
-  status,
-  error,
-  hasCred,
-}: {
-  kind: string;
-  status: string;
-  error?: string;
-  hasCred: boolean;
-}) {
-  if (kind !== "spider91" && !hasCred) {
-    return <span className="admin-status is-pending">未配置凭证</span>;
-  }
-  if (status === "ok") {
-    if (kind === "spider91") {
-      return <span className="admin-status is-ok">已就绪</span>;
-    }
-    return <span className="admin-status is-ok">已连接</span>;
-  }
-  if (status === "error")
-    return (
-      <span className="admin-status is-error" title={error}>
-        错误
-      </span>
-    );
-  return <span className="admin-status">{status || "未连接"}</span>;
-}
-
-export function DriveCardMetrics({ d }: { d: api.AdminDrive }) {
-  return (
-    <div className="admin-drive-card__info">
-      <div className="admin-drive-card__metric">
-        <span>封面数 (就绪/失败)</span>
-        <strong>
-          {d.thumbnailReadyCount ?? 0}
-          <span style={{ fontSize: "11px", fontWeight: "normal", color: "var(--text-faint)" }}>
-            {" "}/ {d.thumbnailFailedCount ?? 0}
-          </span>
-        </strong>
-      </div>
-      <div className="admin-drive-card__metric">
-        <span>预览视频数 (就绪/失败)</span>
-        <strong>
-          {d.teaserReadyCount ?? 0}
-          <span style={{ fontSize: "11px", fontWeight: "normal", color: "var(--text-faint)" }}>
-            {" "}/ {d.teaserFailedCount ?? 0}
-          </span>
-        </strong>
-      </div>
-      <div className="admin-drive-card__metric">
-        <span>视频指纹数 (就绪/失败)</span>
-        <strong>
-          {d.fingerprintReadyCount ?? 0}
-          <span style={{ fontSize: "11px", fontWeight: "normal", color: "var(--text-faint)" }}>
-            {" "}/ {d.fingerprintFailedCount ?? 0}
-          </span>
-        </strong>
-      </div>
-    </div>
-  );
-}
-
-export function DriveGenerationPanel({
-  d,
-  regenFailedId,
-  regenFailedThumbId,
-  regenFailedFingerprintId,
-  togglingTeaserId,
-  onToggleTeaser,
-  onRegenFailed,
-  onRegenFailedThumbnails,
-  onRegenFailedFingerprints,
-}: {
-  d: api.AdminDrive;
-  regenFailedId: string;
-  regenFailedThumbId: string;
-  regenFailedFingerprintId: string;
-  togglingTeaserId: string;
-  onToggleTeaser: () => void;
-  onRegenFailed: () => void;
-  onRegenFailedThumbnails: () => void;
-  onRegenFailedFingerprints: () => void;
-}) {
-  const canQueueThumbnails =
-    (d.thumbnailFailedCount ?? 0) > 0 ||
-    (d.thumbnailPendingCount ?? 0) > 0 ||
-    (d.thumbnailDurationPendingCount ?? 0) > 0;
-  const canQueuePreviews =
-    (d.teaserFailedCount ?? 0) > 0 || (d.teaserPendingCount ?? 0) > 0;
-  const canQueueFingerprints =
-    (d.fingerprintFailedCount ?? 0) > 0 || (d.fingerprintPendingCount ?? 0) > 0;
-
-  return (
-    <div className="admin-detail-card">
-      <header className="admin-detail-card__title">
-        <div className="admin-detail-card__title-left">
-          <PlayCircle size={16} />
-          <span>生成状态</span>
-        </div>
-        <div className="admin-detail-actions-inline">
-          <button
-            className={`admin-btn ${d.teaserEnabled ? "is-success" : ""}`}
-            onClick={onToggleTeaser}
-            disabled={togglingTeaserId === d.id}
-            style={{ padding: "4px 10px", fontSize: "11px" }}
-          >
-            {d.teaserEnabled ? <Power size={11} /> : <PowerOff size={11} />}
-            <span>{d.teaserEnabled ? "预览视频生成：开" : "预览视频生成：关"}</span>
-          </button>
-        </div>
-      </header>
-
-      <div className="admin-detail-grid">
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">封面生成状态</span>
-          <div className="admin-detail-value">
-            <GenerationStatusLine label="封面" status={d.thumbnailGenerationStatus} />
-          </div>
-        </div>
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">封面数量</span>
-          <div className="admin-detail-value">
-            <GenerationCounts
-              ready={d.thumbnailReadyCount}
-              pending={d.thumbnailPendingCount}
-              failed={d.thumbnailFailedCount}
-              durationPending={d.thumbnailDurationPendingCount}
-            />
-          </div>
-        </div>
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">预览视频生成状态</span>
-          <div className="admin-detail-value">
-            <GenerationStatusLine label="预览" status={d.previewGenerationStatus} />
-          </div>
-        </div>
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">预览视频数量</span>
-          <div className="admin-detail-value">
-            <GenerationCounts
-              ready={d.teaserReadyCount}
-              pending={d.teaserPendingCount}
-              failed={d.teaserFailedCount}
-            />
-          </div>
-        </div>
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">视频指纹生成状态</span>
-          <div className="admin-detail-value">
-            <GenerationStatusLine label="指纹" status={d.fingerprintGenerationStatus} />
-          </div>
-        </div>
-        <div className="admin-detail-row">
-          <span className="admin-detail-label">视频指纹数量</span>
-          <div className="admin-detail-value">
-            <GenerationCounts
-              ready={d.fingerprintReadyCount}
-              pending={d.fingerprintPendingCount}
-              failed={d.fingerprintFailedCount}
-            />
-          </div>
-        </div>
-      </div>
-
-      <div className="admin-detail-actions">
-        <button
-          className="admin-btn"
-          disabled={!canQueueThumbnails || regenFailedThumbId === d.id}
-          onClick={onRegenFailedThumbnails}
-        >
-          <RotateCcw size={13} />
-          <span>{(d.thumbnailFailedCount ?? 0) > 0 ? "重试失败封面" : "继续生成封面"}</span>
-        </button>
-        <button
-          className="admin-btn"
-          disabled={!canQueuePreviews || regenFailedId === d.id}
-          onClick={onRegenFailed}
-        >
-          <RotateCcw size={13} />
-          <span>{(d.teaserFailedCount ?? 0) > 0 ? "重试失败预览视频" : "继续生成预览视频"}</span>
-        </button>
-        <button
-          className="admin-btn"
-          disabled={!canQueueFingerprints || regenFailedFingerprintId === d.id}
-          onClick={onRegenFailedFingerprints}
-        >
-          <RotateCcw size={13} />
-          <span>{(d.fingerprintFailedCount ?? 0) > 0 ? "重试失败指纹" : "继续生成指纹"}</span>
-        </button>
-      </div>
-    </div>
-  );
-}

src/admin/drive/DriveForm.tsx

@@ -1,220 +0,0 @@
-import { useId, useMemo, useState } from "react";
-import { ArrowLeft } from "lucide-react";
-import { P123QRCodeLogin } from "./P123QRCodeLogin";
-import { Spider91UploadTargetField } from "./Spider91UploadTargetField";
-import {
-  FormState,
-  Kind,
-  credentialFields,
-  credentialHelp,
-  usesRootDirectoryID,
-  rootIdPlaceholder,
-} from "./constants";
-import * as api from "../api";
-
-type DriveOption = {
-  kind: Kind;
-  label: string;
-  abbr: string;
-};
-
-const DRIVE_OPTIONS: DriveOption[] = [
-  { kind: "p115", label: "115 网盘", abbr: "115" },
-  { kind: "p123", label: "123 云盘", abbr: "123" },
-  { kind: "pikpak", label: "PikPak", abbr: "Pk" },
-  { kind: "onedrive", label: "OneDrive", abbr: "OD" },
-  { kind: "googledrive", label: "Google Drive", abbr: "GD" },
-  { kind: "localstorage", label: "本地存储", abbr: "Lo" },
-  { kind: "spider91", label: "91 爬虫", abbr: "91" },
-  { kind: "quark", label: "夸克网盘", abbr: "Qk" },
-  { kind: "wopan", label: "联通沃盘", abbr: "Wo" },
-];
-
-export function DriveForm({
-  form,
-  onChange,
-  isEdit,
-  uploadTargets,
-  nameError,
-  onNameBlur,
-  onBack,
-}: {
-  form: FormState;
-  onChange: (f: FormState) => void;
-  isEdit: boolean;
-  uploadTargets: api.AdminDrive[];
-  nameError?: string;
-  onNameBlur?: () => void;
-  onBack?: () => void;
-}) {
-  const idPrefix = useId();
-  const fields = useMemo(() => credentialFields(form.kind), [form.kind]);
-  const help = credentialHelp(form.kind, isEdit);
-  const [step, setStep] = useState<"type" | "form">(isEdit ? "form" : "type");
-  const nameId = `${idPrefix}-drive-name`;
-  const rootId = `${idPrefix}-drive-root`;
-
-  function set<K extends keyof FormState>(k: K, v: FormState[K]) {
-    onChange({ ...form, [k]: v });
-  }
-  function setCred(k: string, v: string) {
-    onChange({ ...form, creds: { ...form.creds, [k]: v } });
-  }
-  function setKind(v: Kind) {
-    onChange({
-      ...form,
-      kind: v,
-      rootId: "",
-      creds: {},
-    });
-  }
-  function selectType(kind: Kind) {
-    setKind(kind);
-    setStep("form");
-  }
-  function goBack() {
-    setStep("type");
-    onChange({
-      ...form,
-      name: "",
-      rootId: "",
-      creds: {},
-    });
-    onBack?.();
-  }
-
-  const selectedOption = DRIVE_OPTIONS.find((o) => o.kind === form.kind);
-
-  if (step === "type" && !isEdit) {
-    return (
-      <div className="admin-drive-type-grid">
-        {DRIVE_OPTIONS.map((opt) => (
-          <button
-            key={opt.kind}
-            type="button"
-            className="admin-drive-type-card"
-            onClick={() => selectType(opt.kind)}
-          >
-            <span className="admin-drive-type-card__icon">
-              {opt.abbr}
-            </span>
-            <span className="admin-drive-type-card__label">{opt.label}</span>
-          </button>
-        ))}
-      </div>
-    );
-  }
-
-  return (
-    <div className="admin-form">
-      {!isEdit && (
-        <div className="admin-drive-step-header">
-          <button type="button" className="admin-drive-step-back" onClick={goBack}>
-            <ArrowLeft size={14} /> 重选类型
-          </button>
-          {selectedOption && (
-            <span className="admin-drive-step-badge">
-              <span className="admin-drive-step-badge__abbr">{selectedOption.abbr}</span>
-              <span className="admin-drive-step-badge__label">{selectedOption.label}</span>
-            </span>
-          )}
-        </div>
-      )}
-
-      <div className="admin-form__section">
-        <div className="admin-form__row">
-          <label htmlFor={nameId}>名称 *</label>
-          <input
-            id={nameId}
-            value={form.name}
-            onChange={(e) => set("name", e.target.value)}
-            onBlur={onNameBlur}
-            placeholder="给这个盘起个名字"
-            className={nameError ? "is-invalid" : undefined}
-            aria-invalid={nameError ? "true" : undefined}
-            aria-describedby={nameError ? `${nameId}-error` : undefined}
-          />
-          {nameError && (
-            <div className="admin-form__error" id={`${nameId}-error`}>
-              {nameError}
-            </div>
-          )}
-        </div>
-
-        {usesRootDirectoryID(form.kind) && (
-          <div className="admin-form__row">
-            <label htmlFor={rootId}>根目录 ID</label>
-            <input
-              id={rootId}
-              value={form.rootId}
-              onChange={(e) => set("rootId", e.target.value)}
-              placeholder={rootIdPlaceholder(form.kind)}
-            />
-            <div className="admin-form__help">
-              留空时使用该网盘类型的默认根目录
-            </div>
-          </div>
-        )}
-      </div>
-
-      {(help || fields.length > 0) && (
-        <div className="admin-form__section">
-          <h3 className="admin-form__section-label">凭证配置</h3>
-
-          {help && (
-            <div className="admin-form__help admin-form__help--lead">
-              {help}
-            </div>
-          )}
-
-          {form.kind === "p123" && (
-            <P123QRCodeLogin
-              onToken={(token) => setCred("access_token", token)}
-            />
-          )}
-
-          {fields.map((f) => (
-            <div key={f.key} className="admin-form__row">
-              <label htmlFor={`${idPrefix}-credential-${f.key}`}>
-                {f.label}
-                {f.required && " *"}
-              </label>
-              {f.multiline ? (
-                <textarea
-                  id={`${idPrefix}-credential-${f.key}`}
-                  value={form.creds[f.key] ?? ""}
-                  onChange={(e) => setCred(f.key, e.target.value)}
-                  placeholder={f.placeholder}
-                />
-              ) : (
-                <input
-                  id={`${idPrefix}-credential-${f.key}`}
-                  type={credentialInputType(f.key)}
-                  value={form.creds[f.key] ?? ""}
-                  onChange={(e) => setCred(f.key, e.target.value)}
-                  placeholder={f.placeholder}
-                />
-              )}
-              {f.help && <div className="admin-form__help">{f.help}</div>}
-            </div>
-          ))}
-        </div>
-      )}
-
-      {form.kind === "spider91" && (
-        <div className="admin-form__section">
-          <h3 className="admin-form__section-label">上传设置</h3>
-          <Spider91UploadTargetField
-            value={form.spider91UploadDriveId}
-            onChange={(v) => set("spider91UploadDriveId", v)}
-            uploadTargets={uploadTargets}
-          />
-        </div>
-      )}
-    </div>
-  );
-}
-
-function credentialInputType(key: string): string {
-  return /password|token|secret/i.test(key) ? "password" : "text";
-}

src/admin/drive/P123QRCodeLogin.tsx

@@ -1,142 +0,0 @@
-import { useEffect, useState } from "react";
-import { QrCode } from "lucide-react";
-import * as api from "../api";
-import { useToast } from "../ToastContext";
-
-function p123QRStatusClass(
-  status: api.P123QRStatus | null,
-  completed: boolean,
-  error: string
-): string {
-  if (completed || status?.loginStatus === 3) return "is-ok";
-  if (error || status?.loginStatus === 2 || status?.loginStatus === 4) {
-    return "is-error";
-  }
-  return "is-pending";
-}
-
-export function P123QRCodeLogin({ onToken }: { onToken: (token: string) => void }) {
-  const { show } = useToast();
-  const [session, setSession] = useState<api.P123QRSession | null>(null);
-  const [status, setStatus] = useState<api.P123QRStatus | null>(null);
-  const [starting, setStarting] = useState(false);
-  const [pollingError, setPollingError] = useState("");
-  const [completed, setCompleted] = useState(false);
-
-  async function start() {
-    setStarting(true);
-    setPollingError("");
-    setCompleted(false);
-    setStatus(null);
-    try {
-      const next = await api.startP123QRLogin();
-      setSession(next);
-    } catch (e) {
-      setSession(null);
-      show(e instanceof Error ? e.message : "生成二维码失败", "error");
-    } finally {
-      setStarting(false);
-    }
-  }
-
-  useEffect(() => {
-    if (!session || completed) return;
-    const activeSession = session;
-    let stopped = false;
-    let inFlight = false;
-    let timer: number | undefined;
-
-    async function poll() {
-      if (stopped || inFlight) return;
-      inFlight = true;
-      try {
-        const next = await api.getP123QRStatus(activeSession.uniID, activeSession.loginUuid);
-        if (stopped) return;
-        setStatus(next);
-        setPollingError("");
-        if (next.accessToken) {
-          stopped = true;
-          if (timer) window.clearInterval(timer);
-          setCompleted(true);
-          onToken(next.accessToken);
-          show("扫码成功，已填入 access_token，保存后生效", "success");
-          return;
-        }
-        if (next.loginStatus === 2 || next.loginStatus === 4) {
-          stopped = true;
-          if (timer) window.clearInterval(timer);
-        }
-      } catch (e) {
-        if (stopped) return;
-        setPollingError(e instanceof Error ? e.message : "查询扫码状态失败");
-      } finally {
-        inFlight = false;
-      }
-    }
-
-    poll();
-    timer = window.setInterval(poll, 1800);
-    return () => {
-      stopped = true;
-      if (timer) window.clearInterval(timer);
-    };
-  }, [session, completed, onToken, show]);
-
-  const statusText = completed
-    ? "已获取 token"
-    : pollingError || status?.statusText || (session ? "等待扫码" : "未生成二维码");
-  const statusClass = p123QRStatusClass(status, completed, pollingError);
-  const platform = status?.platformText ? ` · ${status.platformText}` : "";
-
-  return (
-    <div className="admin-form__row">
-      <label>扫码登录</label>
-      <div className="admin-p123-qr">
-        <div className="admin-p123-qr__actions">
-          <button
-            type="button"
-            className="admin-btn"
-            onClick={start}
-            disabled={starting}
-          >
-            <QrCode size={14} />
-            {starting ? "生成中..." : session ? "重新生成二维码" : "生成二维码"}
-          </button>
-          <span className={`admin-status ${statusClass}`}>
-            {statusText}
-            {platform}
-          </span>
-        </div>
-
-        {session && (
-          <div className="admin-p123-qr__body">
-            <img
-              className="admin-p123-qr__image"
-              src={session.qrImageDataUrl}
-              alt="123 云盘扫码登录二维码"
-            />
-            <div className="admin-p123-qr__meta">
-              <div className="admin-form__help">
-                使用微信或 123 云盘 App 扫码并确认登录；确认后系统会自动填入 access_token。
-              </div>
-              {session.expiresAt && (
-                <div className="admin-form__help">
-                  过期时间：{new Date(session.expiresAt).toLocaleTimeString("zh-CN", {
-                    hour: "2-digit",
-                    minute: "2-digit",
-                    second: "2-digit",
-                  })}
-                </div>
-              )}
-              {(status?.loginStatus === 2 || status?.loginStatus === 4) && (
-                <div className="admin-form__help">
-                  当前二维码{status.loginStatus === 2 ? "已被拒绝" : "已过期"}，请重新生成。
-                </div>
-              )}
-            </div>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

src/admin/drive/SkipDirsPanel.tsx

@@ -1,311 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { ChevronDown, ChevronRight } from "lucide-react";
-import * as api from "../api";
-import { useToast } from "../ToastContext";
-import { kindLabel } from "./constants";
-
-type SkipDirsPanelProps = {
-  drive: api.AdminDrive;
-  onSaved: (saved: { id: string; skipDirIds: string[] }) => void;
-};
-
-export function SkipDirsPanel({ drive, onSaved }: SkipDirsPanelProps) {
-  const { show } = useToast();
-  const [selected, setSelected] = useState<Set<string>>(
-    () => new Set(drive.skipDirIds ?? [])
-  );
-  const [saving, setSaving] = useState(false);
-
-  useEffect(() => {
-    setSelected(new Set(drive.skipDirIds ?? []));
-  }, [drive.id, drive.skipDirIds]);
-
-  const toggle = useCallback((id: string) => {
-    setSelected((prev) => {
-      const next = new Set(prev);
-      if (next.has(id)) {
-        next.delete(id);
-      } else {
-        next.add(id);
-      }
-      return next;
-    });
-  }, []);
-
-  async function handleSave() {
-    setSaving(true);
-    try {
-      const ids = Array.from(selected);
-      const resp = await api.setDriveSkipDirIds(drive.id, ids);
-      onSaved({ id: drive.id, skipDirIds: resp.skipDirIds });
-    } catch (e) {
-      show(e instanceof Error ? e.message : "保存失败", "error");
-    } finally {
-      setSaving(false);
-    }
-  }
-
-  const selectedList = useMemo(() => Array.from(selected), [selected]);
-
-  return (
-    <div className="admin-detail-card">
-      <header className="admin-detail-card__title">
-        <div className="admin-detail-card__title-left">
-          <span>扫描跳过目录</span>
-        </div>
-        <button
-          className="admin-btn is-primary"
-          onClick={handleSave}
-          disabled={saving}
-          style={{ padding: "4px 10px", fontSize: "12px", height: "auto" }}
-        >
-          {saving ? "保存中..." : `保存更改 (${selectedList.length})`}
-        </button>
-      </header>
-
-      <div style={{ display: "flex", flexDirection: "column", gap: "12px" }}>
-        <p className="admin-text-faint" style={{ margin: 0, fontSize: "12px", lineHeight: "1.5" }}>
-          勾选要在扫描时跳过的目录。命中目录及其全部子目录都不会被递归扫描。下次扫描生效。
-        </p>
-
-        <SelectedDirsChips
-          drive={drive}
-          selected={selectedList}
-          onRemove={toggle}
-        />
-
-        <div className="admin-detail-tree-container">
-          <DirTreeNode
-            driveId={drive.id}
-            id=""
-            name={drive.name || drive.id}
-            depth={0}
-            initiallyOpen
-            ancestorSkipped={false}
-            selected={selected}
-            onToggle={toggle}
-          />
-        </div>
-      </div>
-    </div>
-  );
-}
-
-function SelectedDirsChips({
-  drive,
-  selected,
-  onRemove,
-}: {
-  drive: api.AdminDrive;
-  selected: string[];
-  onRemove: (id: string) => void;
-}) {
-  if (selected.length === 0) {
-    return (
-      <div
-        className="admin-text-faint"
-        style={{ fontSize: "13px", padding: "6px 0" }}
-      >
-        当前未勾选任何跳过目录（{kindLabel[drive.kind] ?? drive.kind}{" "}
-        将完整扫描）。
-      </div>
-    );
-  }
-  return (
-    <div style={{ display: "flex", flexWrap: "wrap", gap: "6px" }}>
-      {selected.map((id) => (
-        <span
-          key={id}
-          className="admin-mono-cell"
-          style={{
-            display: "inline-flex",
-            alignItems: "center",
-            gap: "6px",
-            padding: "3px 10px",
-            border: "1px solid var(--border-subtle)",
-            borderRadius: "999px",
-            fontSize: "12px",
-          }}
-          title="点击 × 移除"
-        >
-          {id}
-          <button
-            type="button"
-            onClick={() => onRemove(id)}
-            style={{
-              border: "none",
-              background: "transparent",
-              cursor: "pointer",
-              color: "var(--text-secondary)",
-              padding: 0,
-              lineHeight: 1,
-              fontSize: "14px",
-            }}
-            aria-label={`移除 ${id}`}
-          >
-            ×
-          </button>
-        </span>
-      ))}
-    </div>
-  );
-}
-
-type DirTreeNodeProps = {
-  driveId: string;
-  id: string;
-  name: string;
-  depth: number;
-  initiallyOpen?: boolean;
-  ancestorSkipped: boolean;
-  selected: Set<string>;
-  onToggle: (id: string) => void;
-};
-
-function DirTreeNode({
-  driveId,
-  id,
-  name,
-  depth,
-  initiallyOpen,
-  ancestorSkipped,
-  selected,
-  onToggle,
-}: DirTreeNodeProps) {
-  const [open, setOpen] = useState(!!initiallyOpen);
-  const [loading, setLoading] = useState(false);
-  const [loaded, setLoaded] = useState(false);
-  const [children, setChildren] = useState<api.DriveDirEntry[]>([]);
-  const [error, setError] = useState("");
-
-  const isRoot = depth === 0;
-  const isSelected = id !== "" && selected.has(id);
-  const dimmed = ancestorSkipped;
-
-  const loadChildren = useCallback(async () => {
-    if (loaded || loading) return;
-    setLoading(true);
-    setError("");
-    try {
-      const data = await api.listDriveDirChildren(driveId, id || undefined);
-      setChildren(data ?? []);
-      setLoaded(true);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : "加载失败");
-    } finally {
-      setLoading(false);
-    }
-  }, [driveId, id, loaded, loading]);
-
-  useEffect(() => {
-    if (open && !loaded) {
-      void loadChildren();
-    }
-  }, [open, loaded, loadChildren]);
-
-  function handleToggleOpen() {
-    setOpen((v) => !v);
-  }
-
-  return (
-    <div
-      style={{
-        paddingLeft: depth === 0 ? 0 : 16,
-        opacity: dimmed && !isSelected ? 0.55 : 1,
-      }}
-    >
-      <div
-        style={{
-          display: "flex",
-          alignItems: "center",
-          gap: "6px",
-          padding: "4px 6px",
-          borderRadius: "4px",
-          background: isSelected ? "var(--accent-soft, rgba(255,140,0,0.12))" : "transparent",
-        }}
-      >
-        {!isRoot ? (
-          <button
-            type="button"
-            onClick={handleToggleOpen}
-            style={{
-              border: "none",
-              background: "transparent",
-              cursor: "pointer",
-              padding: 0,
-              display: "inline-flex",
-              alignItems: "center",
-            }}
-            aria-label={open ? "折叠" : "展开"}
-          >
-            {open ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
-          </button>
-        ) : (
-          <span style={{ width: 14, display: "inline-block" }} />
-        )}
-
-        {!isRoot && (
-          <input
-            type="checkbox"
-            checked={isSelected}
-            onChange={() => onToggle(id)}
-            aria-label={`跳过目录 ${name}`}
-          />
-        )}
-
-        <span
-          style={{
-            fontSize: "13px",
-            cursor: isRoot ? "default" : "pointer",
-            userSelect: "none",
-            fontWeight: isRoot ? 600 : 400,
-          }}
-          onClick={isRoot ? undefined : handleToggleOpen}
-        >
-          {name}
-          {isRoot ? " (根目录)" : ""}
-        </span>
-        {!isRoot && (
-          <span
-            className="admin-mono-cell admin-text-faint"
-            style={{ fontSize: "11px", marginLeft: "6px" }}
-          >
-            {id}
-          </span>
-        )}
-      </div>
-
-      {open && (
-        <div>
-          {loading && (
-            <div className="admin-text-faint" style={{ fontSize: "12px", padding: "4px 28px" }}>
-              加载中...
-            </div>
-          )}
-          {error && (
-            <div style={{ fontSize: "12px", padding: "4px 28px", color: "var(--danger, #d33)" }}>
-              {error}
-            </div>
-          )}
-          {loaded && !error && children.length === 0 && (
-            <div className="admin-text-faint" style={{ fontSize: "12px", padding: "4px 28px" }}>
-              （无子目录）
-            </div>
-          )}
-          {children.map((child) => (
-            <DirTreeNode
-              key={child.id}
-              driveId={driveId}
-              id={child.id}
-              name={child.name}
-              depth={depth + 1}
-              ancestorSkipped={ancestorSkipped || isSelected}
-              selected={selected}
-              onToggle={onToggle}
-            />
-          ))}
-        </div>
-      )}
-    </div>
-  );
-}

src/admin/drive/Spider91UploadTargetField.tsx

@@ -1,32 +0,0 @@
-import { useId } from "react";
-import { kindLabel } from "./constants";
-import * as api from "../api";
-
-export function Spider91UploadTargetField({
-  value,
-  onChange,
-  uploadTargets,
-}: {
-  value: string;
-  onChange: (v: string) => void;
-  uploadTargets: api.AdminDrive[];
-}) {
-  const targetId = useId();
-
-  return (
-    <div className="admin-form__row">
-      <label htmlFor={targetId}>视频上传目标</label>
-      <select id={targetId} value={value} onChange={(e) => onChange(e.target.value)}>
-        <option value="">本地保存，不上传</option>
-        {uploadTargets.map((d) => (
-          <option key={d.id} value={d.id}>
-            {kindLabel[d.kind] ?? d.kind} · {d.name || d.id}
-          </option>
-        ))}
-      </select>
-      <div className="admin-form__help">
-        选择本地保存时，爬取视频只保存在服务器本地；选择 115 网盘、123 云盘、PikPak 或 OneDrive 后，较早的视频会上传到该云盘根目录下的 91 Spider 文件夹。该设置全局生效。
-      </div>
-    </div>
-  );
-}

src/admin/drive/constants.ts

@@ -1,271 +0,0 @@
-export type Kind = "quark" | "p115" | "p123" | "pikpak" | "wopan" | "onedrive" | "googledrive" | "localstorage" | "spider91";
-
-export const kindLabel: Record<string, string> = {
-  quark: "夸克网盘",
-  p115: "115 网盘",
-  p123: "123 云盘",
-  pikpak: "PikPak",
-  wopan: "联通沃盘",
-  onedrive: "OneDrive",
-  googledrive: "Google Drive",
-  localstorage: "本地存储",
-  spider91: "91 爬虫",
-};
-
-export type FormState = {
-  id: string;
-  kind: Kind;
-  name: string;
-  rootId: string;
-  creds: Record<string, string>;
-  spider91UploadDriveId: string;
-};
-
-export const emptyForm: FormState = {
-  id: "",
-  kind: "p115",
-  name: "",
-  rootId: "",
-  creds: {},
-  spider91UploadDriveId: "",
-};
-
-export const idleNightlyStatus = {
-  state: "idle" as const,
-  running: false,
-  queued: false,
-};
-
-export function nightlyButtonText(status: { running: boolean; queued: boolean }, triggering: boolean) {
-  if (triggering) return "触发中...";
-  if (status.running) return "扫描运行中";
-  if (status.queued) return "扫描已排队";
-  return "扫描所有网盘";
-}
-
-export function nightlyBusyText(status: { running: boolean; queued: boolean }) {
-  if (status.running) return "扫描任务正在运行";
-  if (status.queued) return "扫描任务已排队";
-  return "";
-}
-
-export function generationStateLabel(state: string): string {
-  if (state === "generating") return "生成中";
-  if (state === "cooling") return "冷却中";
-  if (state === "queued") return "排队中";
-  return "空闲";
-}
-
-export function generationStateClass(state: string): string {
-  if (state === "generating" || state === "cooling" || state === "queued") {
-    return state;
-  }
-  return "idle";
-}
-
-export function generationDetail(status?: { state: string; cooldownUntil?: string; currentTitle?: string }): string {
-  if (!status) return "";
-  if (status.state === "cooling" && status.cooldownUntil) {
-    return `剩余 ${formatCooldownRemaining(status.cooldownUntil)}`;
-  }
-  if (status.currentTitle) {
-    return status.currentTitle;
-  }
-  return "";
-}
-
-export function generationTitle(status: { state: string; cooldownUntil?: string; currentTitle?: string } | undefined, detail: string): string | undefined {
-  if (!status) return detail || undefined;
-  if (status.state === "cooling" && status.cooldownUntil) {
-    return `冷却至 ${formatClock(status.cooldownUntil)}`;
-  }
-  return status.currentTitle || detail || undefined;
-}
-
-export function formatCooldownRemaining(value: string): string {
-  const d = new Date(value);
-  if (Number.isNaN(d.getTime())) return value;
-  const totalSeconds = Math.max(0, Math.ceil((d.getTime() - Date.now()) / 1000));
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-  if (hours > 0) return `${hours}小时${minutes}分`;
-  if (minutes > 0) return `${minutes}分${seconds}秒`;
-  return `${seconds}秒`;
-}
-
-export function formatClock(value: string): string {
-  const d = new Date(value);
-  if (Number.isNaN(d.getTime())) return value;
-  return d.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
-}
-
-export function defaultRootId(kind: Kind): string {
-  if (kind === "pikpak") return "";
-  if (kind === "onedrive") return "root";
-  if (kind === "googledrive") return "root";
-  if (kind === "localstorage") return "/";
-  if (kind === "spider91") return "/";
-  return "0";
-}
-
-export function usesRootDirectoryID(kind: Kind): boolean {
-  return kind !== "localstorage" && kind !== "spider91";
-}
-
-export function rootIdPlaceholder(kind: Kind): string {
-  const rootId = defaultRootId(kind);
-  return rootId ? `默认：${rootId}` : "留空表示根目录";
-}
-
-export function credentialHelp(kind: Kind, isEdit: boolean): string {
-  const note = isEdit ? "如不修改凭证，留空即可，保存时会沿用旧值。" : "";
-  switch (kind) {
-    case "quark":
-      return `在 pan.quark.cn 登录后，F12 → Network → 任意请求 → Request Headers 里复制整段 Cookie 粘贴到下方。${note}`;
-    case "p115":
-      return `登录 115.com 后复制 Cookie，形如 "UID=...; CID=...; SEID=...; KID=..."。${note}`;
-    case "p123":
-      return `推荐使用扫码登录自动获取 access_token；账号密码登录被 123 云盘风控拦截时，也可以只填写 access_token。播放走 302 跳转到 123 云盘返回的短期 CDN 地址。${note}`;
-    case "pikpak":
-      return `填写 PikPak 账号和密码即可。平台、设备 ID、验证码 token 和 refresh token 会由服务端自动处理并保存。${note}`;
-    case "wopan":
-      return `需要 access_token 和 refresh_token。后续会加扫码/短信登录入口，第一版只能手工粘贴。${note}`;
-    case "onedrive":
-      return `按 OpenList 默认应用在线挂载，只需要 refresh_token；保存时会自动刷新并保存 token。${note}`;
-    case "googledrive":
-      return `按 OpenList 在线 API 挂载，只需要 Google Drive refresh_token；保存时会自动刷新并保存 token。播放不走 302，会由后端带 Authorization 代理转发。${note}`;
-    case "localstorage":
-      return `把服务器上的一个已有目录作为视频来源扫描。填写绝对路径，例如 /mnt/videos；系统会读取该目录及子目录中的视频，并生成封面、预览视频和指纹。${note}`;
-    case "spider91":
-      return "91 爬虫会把定时抓取到的视频和封面先保存到本机，并作为一个视频来源接入站点；可按服务器网络情况单独配置代理。后续流水线会把较早的视频上传到你选择的 115 / PikPak / OneDrive 目标盘。";
-    default:
-      return "";
-  }
-}
-
-export function credentialFields(kind: Kind): Array<{
-  key: string;
-  label: string;
-  placeholder: string;
-  multiline?: boolean;
-  required?: boolean;
-  help?: string;
-}> {
-  switch (kind) {
-    case "quark":
-      return [
-        {
-          key: "cookie",
-          label: "Cookie",
-          placeholder: "__pus=...; __puus=...; ...",
-          multiline: true,
-          required: true,
-        },
-      ];
-    case "p115":
-      return [
-        {
-          key: "cookie",
-          label: "Cookie",
-          placeholder: "UID=xxx; CID=xxx; SEID=xxx; KID=xxx",
-          multiline: true,
-          required: true,
-        },
-      ];
-    case "p123":
-      return [
-        {
-          key: "username",
-          label: "用户名 / 邮箱（可选）",
-          placeholder: "user@example.com",
-        },
-        {
-          key: "password",
-          label: "密码（可选）",
-          placeholder: "123 云盘密码",
-        },
-        {
-          key: "access_token",
-          label: "access_token（推荐用于风控场景）",
-          placeholder: "Bearer eyJ... 或直接粘贴 token",
-          multiline: true,
-          help: "扫码成功后会自动填入该字段；如果 token 过期，重新扫码后保存即可。",
-        },
-      ];
-    case "pikpak":
-      return [
-        {
-          key: "username",
-          label: "用户名 / 邮箱",
-          placeholder: "user@example.com",
-          required: true,
-        },
-        {
-          key: "password",
-          label: "密码",
-          placeholder: "PikPak 密码",
-          required: true,
-        },
-      ];
-    case "wopan":
-      return [
-        {
-          key: "access_token",
-          label: "access_token",
-          placeholder: "",
-          required: true,
-        },
-        {
-          key: "refresh_token",
-          label: "refresh_token",
-          placeholder: "",
-          required: true,
-        },
-        {
-          key: "family_id",
-          label: "family_id（家庭空间可选）",
-          placeholder: "留空走个人空间",
-        },
-      ];
-    case "onedrive":
-      return [
-        {
-          key: "refresh_token",
-          label: "refresh_token",
-          placeholder: "OpenList OneDrive refresh_token",
-          multiline: true,
-          required: true,
-        },
-      ];
-    case "googledrive":
-      return [
-        {
-          key: "refresh_token",
-          label: "refresh_token",
-          placeholder: "OpenList Google Drive refresh_token",
-          multiline: true,
-          required: true,
-        },
-      ];
-    case "localstorage":
-      return [
-        {
-          key: "path",
-          label: "本地目录路径",
-          placeholder: "/mnt/videos",
-          required: true,
-          help: "路径必须是后端服务器上的已有目录；保存后可手动重扫，系统会递归扫描支持的视频格式。",
-        },
-      ];
-    case "spider91":
-      return [
-        {
-          key: "proxy",
-          label: "代理地址（可选）",
-          placeholder: "http://127.0.0.1:7890",
-          help: "仅用于 91Spider 的列表/详情请求和视频、封面下载；留空则使用服务器环境变量 HTTP_PROXY / HTTPS_PROXY 或直连。支持 http://、https://、socks5:// 或 socks5h://。",
-        },
-      ];
-  }
-}

tests/adminDriveForm.test.ts

@@ -6,83 +6,44 @@ const drivesPageSource = readFileSync(
   new URL("../src/admin/DrivesPage.tsx", import.meta.url),
   "utf8"
 );
-const driveComponentsSource = readFileSync(
-  new URL("../src/admin/drive/DriveComponents.tsx", import.meta.url),
-  "utf8"
-);
-const driveFormSource = readFileSync(
-  new URL("../src/admin/drive/DriveForm.tsx", import.meta.url),
-  "utf8"
-);
-const apiSource = readFileSync(
-  new URL("../src/admin/api.ts", import.meta.url),
-  "utf8"
-);
-const constantsSource = readFileSync(
-  new URL("../src/admin/drive/constants.ts", import.meta.url),
-  "utf8"
-);
-
-const combinedSource = drivesPageSource + "\n" + driveFormSource + "\n" + constantsSource + "\n" + readFileSync(
-  new URL("../src/admin/drive/Spider91UploadTargetField.tsx", import.meta.url),
-  "utf8"
-);
-
-function driveTypeOptions() {
-  const match = /const DRIVE_OPTIONS:\s*DriveOption\[]\s*=\s*\[([\s\S]*?)\];/.exec(
-    driveFormSource
-  );
-  assert.ok(match, "drive option card list should be present");
-  return Array.from(
-    match[1].matchAll(/\{\s*kind:\s*"([^"]+)",\s*label:\s*"([^"]+)"/g),
-    (option) => ({ value: option[1], label: option[2] })
-  );
-}
-
-function assertDriveTypeOption(value: string, label: string) {
-  assert.ok(
-    driveTypeOptions().some((option) => option.value === value && option.label === label),
-    `${value} drive type option should be present`
-  );
-}
 
 test("spider91 drive form does not expose advanced crawler credentials", () => {
-  assert.match(combinedSource, /key: "proxy"/);
-  assert.match(combinedSource, /label: "代理地址（可选）"/);
-  assert.match(combinedSource, /支持 http:\/\/、https:\/\/、socks5:\/\/ 或 socks5h:\/\//);
-  assert.doesNotMatch(combinedSource, /target_new/);
-  assert.doesNotMatch(combinedSource, /crawl_hour/);
-  assert.doesNotMatch(combinedSource, /python_path/);
-  assert.doesNotMatch(combinedSource, /script_path/);
+  assert.match(drivesPageSource, /key: "proxy"/);
+  assert.match(drivesPageSource, /label: "代理地址（可选）"/);
+  assert.match(drivesPageSource, /支持 http:\/\/、https:\/\/、socks5:\/\/ 或 socks5h:\/\//);
+  assert.doesNotMatch(drivesPageSource, /target_new/);
+  assert.doesNotMatch(drivesPageSource, /crawl_hour/);
+  assert.doesNotMatch(drivesPageSource, /python_path/);
+  assert.doesNotMatch(drivesPageSource, /script_path/);
 });
 
 test("spider91 upload target uses explicit local-save option instead of auto target", () => {
-  assert.match(combinedSource, /本地保存，不上传/);
+  assert.match(drivesPageSource, /本地保存，不上传/);
   assert.match(
-    combinedSource,
-    /d\.kind === "pikpak" \|\| d\.kind === "p115" \|\| d\.kind === "p123" \|\| d\.kind === "onedrive"/
+    drivesPageSource,
+    /d\.kind === "pikpak" \|\| d\.kind === "p115" \|\| d\.kind === "onedrive"/
   );
-  assert.doesNotMatch(combinedSource, /自动：唯一/);
-  assert.doesNotMatch(combinedSource, /自动模式/);
+  assert.doesNotMatch(drivesPageSource, /自动：唯一/);
+  assert.doesNotMatch(drivesPageSource, /自动模式/);
 });
 
 test("drive form hides root directory id for localstorage and spider91", () => {
-  assert.match(combinedSource, /<label[^>]*>根目录 ID<\/label>/);
+  assert.match(drivesPageSource, /<label>根目录 ID<\/label>/);
   assert.match(
-    combinedSource,
-    /usesRootDirectoryID\(kind:\s*Kind\):\s*boolean\s*\{\s*return kind !== "localstorage" && kind !== "spider91";\s*\}/
+    drivesPageSource,
+    /function usesRootDirectoryID\(kind: Kind\): boolean \{\s*return kind !== "localstorage" && kind !== "spider91";\s*\}/
   );
-  assert.match(combinedSource, /\{usesRootDirectoryID\(form\.kind\) && \(/);
-  assert.match(combinedSource, /\{usesRootDirectoryID\(d\.kind\) && \(/);
-  assert.match(combinedSource, /placeholder=\{rootIdPlaceholder\(form\.kind\)\}/);
-  assert.doesNotMatch(combinedSource, /扫描起点目录 ID/);
-  assert.doesNotMatch(combinedSource, /set\("scanRootId"/);
+  assert.match(drivesPageSource, /\{usesRootDirectoryID\(form\.kind\) && \(/);
+  assert.match(drivesPageSource, /\{usesRootDirectoryID\(d\.kind\) && \(/);
+  assert.match(drivesPageSource, /placeholder=\{rootIdPlaceholder\(form\.kind\)\}/);
+  assert.doesNotMatch(drivesPageSource, /扫描起点目录 ID/);
+  assert.doesNotMatch(drivesPageSource, /set\("scanRootId"/);
 });
 
 test("onedrive drive form only exposes required default-app fields", () => {
   const match =
-    /case "onedrive":\s*return \[([\s\S]*?)\];\s*case "googledrive":/.exec(
-      combinedSource
+    /function credentialFields[\s\S]*?case "onedrive":\s*return \[([\s\S]*?)\];\s*case "googledrive":/.exec(
+      drivesPageSource
     );
   assert.ok(match, "onedrive credential field block should be present");
   const fields = match[1];
@@ -96,11 +57,11 @@ test("onedrive drive form only exposes required default-app fields", () => {
 });
 
 test("googledrive drive form only exposes refresh token", () => {
-  assertDriveTypeOption("googledrive", "Google Drive");
+  assert.match(drivesPageSource, /<option value="googledrive">Google Drive<\/option>/);
 
   const match =
     /case "googledrive":\s*return \[([\s\S]*?)\];\s*case "localstorage":/.exec(
-      combinedSource
+      drivesPageSource
     );
   assert.ok(match, "googledrive credential field block should be present");
   const fields = match[1];
@@ -115,7 +76,7 @@ test("googledrive drive form only exposes refresh token", () => {
 test("pikpak drive form only exposes account login fields", () => {
   const match =
     /case "pikpak":\s*return \[([\s\S]*?)\];\s*case "wopan":/.exec(
-      combinedSource
+      drivesPageSource
     );
   assert.ok(match, "pikpak credential field block should be present");
   const fields = match[1];
@@ -130,79 +91,37 @@ test("pikpak drive form only exposes account login fields", () => {
 });
 
 test("localstorage drive form asks for a server directory path", () => {
-  assertDriveTypeOption("localstorage", "本地存储");
+  assert.match(drivesPageSource, /<option value="localstorage">本地存储<\/option>/);
 
   const match =
     /case "localstorage":\s*return \[([\s\S]*?)\];\s*case "spider91":/.exec(
-      combinedSource
+      drivesPageSource
     );
   assert.ok(match, "localstorage credential field block should be present");
   const fields = match[1];
 
   assert.match(fields, /key: "path"/);
   assert.match(fields, /label: "本地目录路径"/);
-  assert.match(combinedSource, /if \(kind === "localstorage"\) return "\/"/);
-  assert.match(combinedSource, /kind !== "localstorage" && kind !== "spider91"/);
+  assert.match(drivesPageSource, /if \(kind === "localstorage"\) return "\/"/);
+  assert.match(drivesPageSource, /kind !== "localstorage" && kind !== "spider91"/);
 });
 
 test("drive type selector keeps primary source order", () => {
-  assert.deepEqual(driveTypeOptions(), [
+  const options = Array.from(
+    drivesPageSource.matchAll(/<option value="([^"]+)">([^<]+)<\/option>/g),
+    (match) => ({ value: match[1], label: match[2] })
+  );
+  const driveOptions = options.slice(0, 9);
+
+  assert.deepEqual(driveOptions, [
     { value: "p115", label: "115 网盘" },
     { value: "p123", label: "123 云盘" },
     { value: "pikpak", label: "PikPak" },
     { value: "onedrive", label: "OneDrive" },
     { value: "googledrive", label: "Google Drive" },
     { value: "localstorage", label: "本地存储" },
-    { value: "spider91", label: "91 爬虫" },
+    { value: "spider91", label: "91 Spider" },
     { value: "quark", label: "夸克网盘" },
     { value: "wopan", label: "联通沃盘" },
   ]);
 });
-
-test("drive management exposes stop task controls", () => {
-  assert.match(apiSource, /stopDriveTasks/);
-  assert.match(apiSource, /\/drives\/\$\{encodeURIComponent\(id\)\}\/tasks\/stop/);
-  assert.match(apiSource, /stopAllTasks/);
-  assert.match(apiSource, /"\/tasks\/stop"/);
-  assert.match(drivesPageSource, /is-stop/);
-  assert.match(drivesPageSource, /停止所有任务/);
-  assert.match(drivesPageSource, /停止所有网盘任务/);
-});
-
-test("drive detail selection is stored in the URL history", () => {
-  assert.match(drivesPageSource, /useSearchParams/);
-  assert.match(drivesPageSource, /searchParams\.get\("drive"\)/);
-  assert.match(drivesPageSource, /function openDriveDetail\(id: string\)/);
-  assert.match(drivesPageSource, /next\.set\("drive", id\)/);
-  assert.match(drivesPageSource, /function closeDriveDetail/);
-  assert.match(drivesPageSource, /next\.delete\("drive"\)/);
-  assert.doesNotMatch(drivesPageSource, /setSelectedDriveId/);
-});
-
-test("drive discard confirmation matches delete confirmation modal styling", () => {
-  const discardModals = Array.from(
-    drivesPageSource.matchAll(/<ConfirmModal[\s\S]*?title="放弃未保存更改"[\s\S]*?\/>/g),
-    (match) => match[0]
-  );
-
-  assert.equal(discardModals.length, 2);
-  for (const modal of discardModals) {
-    assert.match(modal, /danger/);
-    assert.match(modal, /centerMessage/);
-    assert.match(modal, /modalClassName="admin-modal--delete-confirm"/);
-  }
-});
-
-test("drive generation actions can resume pending work after stop", () => {
-  assert.match(driveComponentsSource, /thumbnailPendingCount/);
-  assert.match(driveComponentsSource, /teaserPendingCount/);
-  assert.match(driveComponentsSource, /fingerprintPendingCount/);
-  assert.match(driveComponentsSource, /继续生成封面/);
-  assert.match(driveComponentsSource, /继续生成预览视频/);
-  assert.match(driveComponentsSource, /继续生成指纹/);
-});
-
-test("drive cards label fingerprint count as video fingerprint count", () => {
-  assert.match(driveComponentsSource, /视频指纹数 \(就绪\/失败\)/);
-  assert.doesNotMatch(driveComponentsSource, />指纹数 \(就绪\/失败\)</);
-});

tests/adminResponsive.test.ts

@@ -6,10 +6,6 @@ const adminCss = readFileSync(
   new URL("../src/styles/admin.css", import.meta.url),
   "utf8"
 );
-const videosPageSource = readFileSync(
-  new URL("../src/admin/VideosPage.tsx", import.meta.url),
-  "utf8"
-);
 
 function ruleBody(css: string, selector: string): string {
   const escapedSelector = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -70,63 +66,6 @@ test("admin tables scroll inside the mobile viewport", () => {
   assert.match(body, /display\s*:\s*block/);
 });
 
-test("admin video filter select uses an aligned custom arrow", () => {
-  const select = ruleBody(adminCss, ".admin-videos-filter__select");
-  const icon = ruleBody(adminCss, ".admin-videos-filter__select-icon");
-  const mobileWrap = ruleBodyByContains(mobileCss(), ".admin-videos-filter__select-wrap");
-
-  assert.match(select, /appearance\s*:\s*none/);
-  assert.match(select, /padding\s*:\s*0\s+36px\s+0\s+var\(--space-3\)/);
-  assert.match(icon, /top\s*:\s*50%/);
-  assert.match(icon, /right\s*:\s*12px/);
-  assert.match(icon, /transform\s*:\s*translateY\(-50%\)/);
-  assert.match(mobileWrap, /flex\s*:\s*1\s+1\s+100%/);
-});
-
-test("admin video bulk actions use semantic theme colors", () => {
-  const base = ruleBody(adminCss, ".admin-videos-bulk-actions__btn");
-  const primary = ruleBody(adminCss, ".admin-videos-bulk-actions__btn.is-primary");
-  const danger = ruleBody(adminCss, ".admin-videos-bulk-actions__btn.is-danger");
-  const dangerHover = ruleBody(adminCss, ".admin-videos-bulk-actions__btn.is-danger:hover:not(:disabled)");
-  const bulkBodies = [base, primary, danger, dangerHover].join("\n");
-
-  assert.match(videosPageSource, /className="admin-btn is-primary admin-videos-bulk-actions__btn"/);
-  assert.match(videosPageSource, /className="admin-btn is-danger admin-videos-bulk-actions__btn"/);
-  assert.match(primary, /var\(--accent-glow\)/);
-  assert.match(danger, /background\s*:\s*var\(--danger-soft\)/);
-  assert.match(danger, /border-color\s*:\s*var\(--danger\)/);
-  assert.match(danger, /color\s*:\s*var\(--danger\)/);
-  assert.match(dangerHover, /background\s*:\s*var\(--danger\)/);
-  assert.doesNotMatch(bulkBodies, /#ff5b8a|#fff6f9|rgba\(255,\s*91,\s*138/);
-});
-
-test("mobile video management uses compact theme-aware video cards", () => {
-  const css = mobileCss();
-  const card = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) tr");
-  const title = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) td[data-label=\"标题\"]");
-  const label = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) td::before");
-  const pills = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) .admin-video-filemeta-pills");
-  const sourceColumn = ruleBodyByContains(css, ".admin-videos-table:not(.admin-drives-table) td[data-label=\"来源\"]");
-  const actionButton = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) td.is-actions .admin-btn");
-  const dangerButton = ruleBody(css, ".admin-videos-table:not(.admin-drives-table) td.is-actions .admin-btn.is-danger");
-
-  assert.match(card, /--admin-video-card-bg\s*:\s*var\(--bg-surface\)/);
-  assert.match(card, /background\s*:\s*var\(--admin-video-card-bg\)/);
-  assert.match(card, /border-radius\s*:\s*14px/);
-  assert.match(card, /padding\s*:\s*12px\s+14px/);
-  assert.match(css, /:root:not\(\[data-theme="pink"\]\)\s+\.admin-videos-table:not\(\.admin-drives-table\)\s+tr\s*\{[^}]*--admin-video-card-bg\s*:\s*#1e1e1e/s);
-  assert.match(css, /:root\[data-theme="pink"\]\s+\.admin-videos-table:not\(\.admin-drives-table\)\s+tr\s*\{/);
-  assert.match(title, /padding-left\s*:\s*36px/);
-  assert.match(label, /font-size\s*:\s*10px/);
-  assert.match(label, /letter-spacing\s*:\s*0\.06em/);
-  assert.match(pills, /display\s*:\s*flex/);
-  assert.doesNotMatch(sourceColumn, /border-left/);
-  assert.match(actionButton, /height\s*:\s*28px/);
-  assert.match(actionButton, /border-radius\s*:\s*8px/);
-  assert.match(dangerButton, /border-color\s*:\s*var\(--admin-video-card-danger-border\)/);
-  assert.match(dangerButton, /color\s*:\s*var\(--admin-video-card-danger\)/);
-});
-
 test("admin modals and action footers adapt on mobile", () => {
   const css = mobileCss();
 
@@ -135,10 +74,6 @@ test("admin modals and action footers adapt on mobile", () => {
   assert.match(ruleBody(adminCss, ".admin-modal"), /width\s*:\s*min\(\d+px,\s*100%\)/);
   // 多按钮 footer 在 mobile 下要换行避免溢出。
   assert.match(allRuleBodies(css, ".admin-modal__footer"), /flex-wrap\s*:\s*wrap/);
-  // 删除/放弃类确认弹窗在 mobile 下不能跟随通用 modal stretch 到顶部。
-  const confirmModal = ruleBody(css, ".admin-modal--delete-confirm");
-  assert.match(confirmModal, /align-self\s*:\s*center/);
-  assert.match(confirmModal, /justify-self\s*:\s*center/);
   // 表单 input/select/textarea 在 mobile 下铺满。规则用逗号合并写法（多 selector
   // 共享 body），所以走 ruleBodyByContains 而不是简单正则。
   assert.match(ruleBodyByContains(css, ".admin-form__row input"), /width\s*:\s*100%/);

tests/adminVideosPagination.test.ts

@@ -1,13 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { test } from "node:test";
-
-const videosPageSource = readFileSync(new URL("../src/admin/VideosPage.tsx", import.meta.url), "utf8");
-
-test("admin videos page uses responsive page size", () => {
-  assert.match(videosPageSource, /const DESKTOP_VIDEOS_PAGE_SIZE = 50;/);
-  assert.match(videosPageSource, /const MOBILE_VIDEOS_PAGE_SIZE = 20;/);
-  assert.match(videosPageSource, /const VIDEOS_MOBILE_QUERY = "\(max-width: 640px\)";/);
-  assert.match(videosPageSource, /window\.matchMedia\(VIDEOS_MOBILE_QUERY\)/);
-  assert.match(videosPageSource, /api\.listVideos\(\{ driveId, page, size: pageSize, keyword: searchKeyword \}\)/);
-});