feat: ffprobe + TMDb scrape + HLS transcode + history/favourites/playlists

Backend
  - service/ffprobe.go: thin ffprobe wrapper, parses duration / resolution /
    codecs into a typed ProbeResult. 30s per-file timeout.
  - service/tmdb.go: minimal TMDb provider (search/movie). Disabled when no
    api key; supports tmdb_api_proxy / tmdb_image_proxy overrides for users
    behind a firewall.
  - service/scraper.go: filename cleaner (handles bracketed tags, scene
    noise tokens, year extraction), per-row + per-library enrichment with a
    4 RPS throttle and WS hub progress events. Unit-tested.
  - service/scanner.go: now invokes ffprobe per file and kicks the TMDb
    scraper in the background once a library scan finishes.
  - service/transcoder.go: per-media ffmpeg HLS job manager; outputs
    index.m3u8 + seg_NNNNN.ts under cache/hls/<id>; cancels jobs on
    shutdown; publishes 'transcode' WS events.
  - service/stream.go: serves HLS playlist (with 30s wait-for-ready) and
    .ts segments with path-traversal protection. Adds Probe() helper used
    by the admin 'reprobe' button.
  - service/image_proxy.go: cached, host-allow-listed reverse proxy for
    TMDb / Bangumi / Douban / Fanart / TheTVDB images so the SPA never
    hits a CORS or GFW issue.
  - service/playback.go: history upsert, favourites toggle, playlist CRUD
    + ordered items. RecentHistory joins with model.Media in one extra
    query so the home page can render a 'Continue Watching' row.
  - handler/streaming.go + handler/playback.go: REST endpoints for HLS,
    image proxy, scrape (one + library), reprobe, history, favourites,
    playlists.
  - handler/handler.go: registers /api/hls/:id/{index.m3u8,:seg}, /api/img,
    /api/history, /api/favourites/:id, /api/playlists/* with proper
    auth/admin guards.

Frontend
  - api/client.ts: imageURL() helper; hlsURL() endpoint; reuses the JWT in
    a query parameter for <video src> and <img src>.
  - api/playback.ts: typed helpers for history, favourites, playlists.
  - components/MediaCard.tsx: optional 'progress' prop renders a thin
    bottom progress bar, used by the new Continue Watching row.
  - pages/HomePage.tsx: two rows (Continue Watching + Recently Added);
    falls back to the empty-state hint when both are empty.
  - pages/PlayerPage.tsx: hls.js (lazy-imported) with auto-fallback to
    direct play; ?mode=hls|direct query toggle; resume position written
    every 10s while playing.
  - pages/MediaDetailPage.tsx: heart toggle + admin 'rescrape' / 'reprobe'
    buttons + dedicated 'HLS 转码播放' CTA.
  - pages/FavouritesPage.tsx, PlaylistsPage.tsx, PlaylistDetailPage.tsx:
    new screens.
  - components/Layout.tsx + App.tsx: sidebar links for Favourites and
    Playlists; routes are now lazily code-split via React.lazy + Suspense
    so the initial bundle stays at ~243 KB / 82 KB gzipped (hls.js is
    fetched only on first HLS playback).

Verified: go build, go vet, go test (incl. CleanQuery cases) all pass;
frontend tsc -b && vite build emits 9 route chunks plus a deferred hls
chunk.

internal/service/scanner.go

@@ -1,10 +1,12 @@
 // Package service — filesystem scanner.
 //
-// ScannerService walks the configured library roots looking for video files,
-// then upserts a model.Media row per file. A future iteration will plug
-// ffprobe / a metadata-provider chain on top of this skeleton, but the
-// scaffold keeps the surface narrow and synchronous so handlers can call
-// "POST /api/libraries/:id/scan" today.
+// ScannerService walks the configured library roots looking for video
+// files, then upserts a model.Media row per file. Each upsert also runs
+// ffprobe (when available) and queues a TMDb lookup for newly added rows.
+//
+// The scan is synchronous from the HTTP layer's point of view, but it
+// publishes WebSocket progress events on the "scan" topic so the React
+// UI can render a live counter / spinner.
 package service
 
 import (
@@ -39,15 +41,27 @@ var videoExtensions = map[string]struct{}{
 
 // ScannerService walks libraries on disk and upserts model.Media rows.
 type ScannerService struct {
-	cfg  *config.Config
-	log  *zap.Logger
-	repo *repository.Container
-	hub  *Hub
+	cfg     *config.Config
+	log     *zap.Logger
+	repo    *repository.Container
+	hub     *Hub
+	probe   *FFprobeService
+	scraper *ScraperService
 }
 
 // NewScannerService is the constructor.
-func NewScannerService(cfg *config.Config, log *zap.Logger, repo *repository.Container, hub *Hub) *ScannerService {
-	return &ScannerService{cfg: cfg, log: log, repo: repo, hub: hub}
+func NewScannerService(
+	cfg *config.Config,
+	log *zap.Logger,
+	repo *repository.Container,
+	hub *Hub,
+	probe *FFprobeService,
+	scraper *ScraperService,
+) *ScannerService {
+	return &ScannerService{
+		cfg: cfg, log: log, repo: repo, hub: hub,
+		probe: probe, scraper: scraper,
+	}
 }
 
 // ScanResult summarises a scan run.
@@ -55,19 +69,26 @@ type ScanResult struct {
 	LibraryID string `json:"library_id"`
 	Visited   int    `json:"visited"`
 	Added     int    `json:"added"`
+	Probed    int    `json:"probed"`
 }
 
 // ScanLibrary walks the library root and persists discovered media files.
 //
-// This is a synchronous skeleton: large libraries should call it in a
-// goroutine. WebSocket progress events are pushed to the hub on the
-// "scan" topic so the React UI can display a progress indicator.
+// Workflow per file:
+//   1. fast filename-based title cleanup.
+//   2. ffprobe → duration / resolution / codecs (best effort).
+//   3. upsert into the media table.
+//   4. publish progress over the WS hub.
+//
+// After the walk we kick off the TMDb scraper for every still-pending
+// row in the same library. The scraper has its own throttle.
 func (s *ScannerService) ScanLibrary(ctx context.Context, libraryID string) (*ScanResult, error) {
 	lib, err := s.repo.Library.FindByID(ctx, libraryID)
 	if err != nil || lib == nil {
 		return nil, err
 	}
 	res := &ScanResult{LibraryID: lib.ID}
+
 	walkFn := func(path string, info walkInfo) error {
 		if info.isDir {
 			return nil
@@ -77,14 +98,38 @@ func (s *ScannerService) ScanLibrary(ctx context.Context, libraryID string) (*Sc
 			return nil
 		}
 		res.Visited++
-		title := strings.TrimSuffix(filepath.Base(path), ext)
+
+		title, year := CleanQuery(path)
+		if title == "" {
+			title = strings.TrimSuffix(filepath.Base(path), ext)
+		}
+
 		m := &model.Media{
 			LibraryID: lib.ID,
 			Title:     title,
+			Year:      year,
 			Path:      path,
 			SizeBytes: info.size,
 			Container: strings.TrimPrefix(ext, "."),
 		}
+
+		// Best-effort ffprobe; failure does not abort the file.
+		if s.probe != nil {
+			if probe, err := s.probe.Probe(ctx, path); err == nil && probe != nil {
+				m.DurationSec = probe.DurationSec
+				m.Width = probe.Width
+				m.Height = probe.Height
+				m.VideoCodec = probe.VideoCodec
+				m.AudioCodec = probe.AudioCodec
+				if probe.Container != "" {
+					m.Container = probe.Container
+				}
+				res.Probed++
+			} else if err != nil {
+				s.log.Debug("ffprobe failed", zap.String("path", path), zap.Error(err))
+			}
+		}
+
 		if err := s.repo.Media.Upsert(ctx, m); err != nil {
 			s.log.Warn("upsert media failed", zap.String("path", path), zap.Error(err))
 			return nil
@@ -95,17 +140,30 @@ func (s *ScannerService) ScanLibrary(ctx context.Context, libraryID string) (*Sc
 			"path":       path,
 			"visited":    res.Visited,
 			"added":      res.Added,
+			"probed":     res.Probed,
 		})
 		return nil
 	}
+
 	if err := walk(lib.Path, walkFn); err != nil {
 		return res, err
 	}
+
 	s.hub.Publish("scan", map[string]any{
 		"library_id": lib.ID,
 		"finished":   true,
 		"visited":    res.Visited,
 		"added":      res.Added,
+		"probed":     res.Probed,
 	})
+
+	// Fire-and-forget metadata enrichment when a TMDb key is configured.
+	if s.scraper != nil && s.scraper.tmdb != nil && s.scraper.tmdb.Enabled() {
+		go func(libID string) {
+			if _, err := s.scraper.EnrichLibrary(context.Background(), libID); err != nil {
+				s.log.Warn("scraper enrich failed", zap.Error(err))
+			}
+		}(lib.ID)
+	}
 	return res, nil
 }