Resolve merge conflicts: merge all Go backend and React frontend changes

internal/handler/assistant.go

@@ -0,0 +1,147 @@
+// Package handler — multi-turn AI assistant chat endpoints.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func listAssistantSessionsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		rows, err := svc.Assistant.ListSessions(
+			c.Request.Context(), toString(uid), role == "admin",
+		)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+type createSessionReq struct {
+	Title string `json:"title"`
+}
+
+func createAssistantSessionHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req createSessionReq
+		_ = c.ShouldBindJSON(&req)
+		uid, _ := c.Get(middleware.CtxUserID)
+		sess, err := svc.Assistant.CreateSession(c.Request.Context(), toString(uid), req.Title)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, sess)
+	}
+}
+
+func getAssistantSessionHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		view, err := svc.Assistant.GetSession(
+			c.Request.Context(), c.Param("id"), toString(uid), role == "admin",
+		)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, view)
+	}
+}
+
+func deleteAssistantSessionHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		if err := svc.Assistant.DeleteSession(
+			c.Request.Context(), c.Param("id"), toString(uid), role == "admin",
+		); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+type chatReq struct {
+	SessionID string `json:"session_id" binding:"required"`
+	Message   string `json:"message" binding:"required"`
+}
+
+func assistantChatHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req chatReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		view, err := svc.Assistant.Chat(
+			c.Request.Context(), req.SessionID, toString(uid), req.Message, role == "admin",
+		)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, view)
+	}
+}
+
+type executeReq struct {
+	SessionID string                 `json:"session_id" binding:"required"`
+	Action    map[string]interface{} `json:"action" binding:"required"`
+}
+
+func assistantExecuteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req executeReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		uid, _ := c.Get(middleware.CtxUserID)
+		opID, err := svc.Assistant.Execute(
+			c.Request.Context(), req.SessionID, toString(uid), req.Action,
+		)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"op_id": opID})
+	}
+}
+
+func assistantUndoHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Assistant.Undo(c.Request.Context(), c.Param("op_id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+func assistantHistoryHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		rows, err := svc.Assistant.History(
+			c.Request.Context(), toString(uid), role == "admin",
+		)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": rows})
+	}
+}

internal/handler/auth_extra.go

@@ -0,0 +1,44 @@
+// Package handler — auth surface beyond /login + /register:
+//
+//	POST /auth/refresh   — issue a fresh JWT for the current user
+//	POST /auth/logout    — best-effort no-op (kept for parity)
+//	PATCH /auth/profile  — alias for /me
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// refreshHandler returns a fresh token signed for the current user.
+// Because we don't track refresh tokens server-side, the caller's
+// existing access token is sufficient — it must already pass the
+// AuthRequired middleware.
+func refreshHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		u, err := svc.Repo.User.FindByID(c.Request.Context(), toString(uid))
+		if err != nil || u == nil {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid session"})
+			return
+		}
+		token, err := svc.Auth.IssueToken(u)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"token": token, "user": u})
+	}
+}
+
+// logoutHandler is a deliberate no-op (we use stateless JWT). It exists
+// so the Vue frontend's logout button gets a 200 instead of 404.
+func logoutHandler(_ *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Status(http.StatusNoContent)
+	}
+}

internal/handler/discover_extra.go

@@ -0,0 +1,79 @@
+// Package handler — multi-section discover endpoints.
+//
+// The Vue DiscoverView paginates a configurable list of "sections"
+// (trending day/week, popular movies, top rated, etc.) and asks the
+// backend for a feed keyed by section name. We mirror that surface so
+// the React DiscoverPage can render the same rails without a rewrite.
+package handler
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// discoverSectionsHandler returns the catalog of sections the UI can
+// pick from. The names match the upstream Vue UI so existing settings
+// keep working.
+func discoverSectionsHandler(_ *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"sections": []gin.H{
+				{"key": "trending_day", "label": "今日热门"},
+				{"key": "trending_week", "label": "本周热门"},
+				{"key": "popular_movie", "label": "热门电影"},
+				{"key": "popular_tv", "label": "热门剧集"},
+				{"key": "top_rated_movie", "label": "高分电影"},
+				{"key": "upcoming_movie", "label": "即将上映"},
+			},
+		})
+	}
+}
+
+// discoverFeedHandler resolves one or more section keys (?sections=a,b)
+// to TMDb endpoint paths and returns the joined results keyed by
+// section name. Unknown keys are silently dropped so URL typos don't
+// break the page.
+func discoverFeedHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keys := strings.Split(c.DefaultQuery("sections", "trending_day,popular_movie"), ",")
+		out := gin.H{}
+		for _, raw := range keys {
+			k := strings.TrimSpace(raw)
+			path := sectionPath(k)
+			if path == "" {
+				continue
+			}
+			items, err := svc.Discover.Fetch(c.Request.Context(), path)
+			if err != nil {
+				svc.Log.Debug("discover fetch failed", )
+				items = nil
+			}
+			out[k] = items
+		}
+		c.JSON(http.StatusOK, out)
+	}
+}
+
+// sectionPath maps the UI-facing key to the TMDb endpoint suffix.
+func sectionPath(k string) string {
+	switch k {
+	case "trending_day":
+		return "/trending/movie/day"
+	case "trending_week":
+		return "/trending/movie/week"
+	case "popular_movie":
+		return "/movie/popular"
+	case "popular_tv":
+		return "/tv/popular"
+	case "top_rated_movie":
+		return "/movie/top_rated"
+	case "upcoming_movie":
+		return "/movie/upcoming"
+	default:
+		return ""
+	}
+}

internal/handler/dlna_extra.go

@@ -0,0 +1,129 @@
+// Package handler — per-renderer DLNA control endpoints used by the
+// Vue UI. These are best-effort SOAP calls; failures surface as 4xx.
+package handler
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// dlnaControlPath maps the action name to the AVTransport SOAP body.
+// (kept for parity with the upstream Vue admin UI)
+type dlnaAction string
+
+const (
+	_dlnaPlay  dlnaAction = "Play"
+	_dlnaPause dlnaAction = "Pause"
+	_dlnaStop  dlnaAction = "Stop"
+)
+
+var _ = []dlnaAction{_dlnaPlay, _dlnaPause, _dlnaStop}
+
+// findRendererControlURL returns the cached control URL for the given
+// uuid (matched against the device UDN). We rely on DLNAService's
+// existing Discover() cache.
+func findRendererControlURL(ctx context.Context, svc *service.Container, uuid string) (string, error) {
+	devs, err := svc.DLNA.Discover(ctx, false)
+	if err != nil {
+		return "", err
+	}
+	for _, d := range devs {
+		if d.UDN == uuid || strings.HasSuffix(d.UDN, uuid) {
+			return d.ControlURL, nil
+		}
+	}
+	return "", errors.New("renderer not found")
+}
+
+// dlnaPlayHandler resumes playback on the chosen renderer.
+func dlnaPlayHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		controlURL, err := findRendererControlURL(c.Request.Context(), svc, c.Param("uuid"))
+		if err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+			return
+		}
+		envelope := buildSimpleAVTransport("Play", `<Speed>1</Speed>`)
+		if err := svc.DLNA.SOAP(c.Request.Context(), controlURL, "Play", envelope); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// dlnaPauseHandler pauses playback on the chosen renderer.
+func dlnaPauseHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		controlURL, err := findRendererControlURL(c.Request.Context(), svc, c.Param("uuid"))
+		if err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+			return
+		}
+		envelope := buildSimpleAVTransport("Pause", "")
+		if err := svc.DLNA.SOAP(c.Request.Context(), controlURL, "Pause", envelope); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// dlnaStopHandler stops playback.
+func dlnaStopHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		controlURL, err := findRendererControlURL(c.Request.Context(), svc, c.Param("uuid"))
+		if err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+			return
+		}
+		envelope := buildSimpleAVTransport("Stop", "")
+		if err := svc.DLNA.SOAP(c.Request.Context(), controlURL, "Stop", envelope); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// dlnaStatusHandler returns "playing" / "paused" / "stopped" via
+// GetTransportInfo. We don't parse the response — the UI can read the
+// raw body via the upstream proxy if it needs more detail.
+func dlnaStatusHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		controlURL, err := findRendererControlURL(c.Request.Context(), svc, c.Param("uuid"))
+		if err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+			return
+		}
+		envelope := buildSimpleAVTransport("GetTransportInfo", "")
+		if err := svc.DLNA.SOAP(c.Request.Context(), controlURL, "GetTransportInfo", envelope); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// buildSimpleAVTransport assembles a SOAP body for the given action +
+// extra body fragment.  InstanceID is hard-coded to 0 (single zone).
+func buildSimpleAVTransport(action string, extra string) string {
+	return fmt.Sprintf(
+		`<?xml version="1.0" encoding="utf-8"?>
+<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/"
+            s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+  <s:Body>
+    <u:%s xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
+      <InstanceID>0</InstanceID>%s
+    </u:%s>
+  </s:Body>
+</s:Envelope>`, action, extra, action,
+	)
+}

internal/handler/download_clients.go

@@ -0,0 +1,90 @@
+// Package handler — download client (qBittorrent / Aria2 / Transmission)
+// configuration endpoints.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func listDownloadClientsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.DownloadClients.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+func createDownloadClientHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.DownloadClientInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		row, err := svc.DownloadClients.Create(c.Request.Context(), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func updateDownloadClientHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.DownloadClientInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		row, err := svc.DownloadClients.Update(c.Request.Context(), c.Param("id"), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func deleteDownloadClientHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.DownloadClients.Delete(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+func testDownloadClientHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.DownloadClients.Test(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"ok": false, "error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+func aria2StatsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		clientID := c.Query("client_id")
+		if clientID == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "client_id required"})
+			return
+		}
+		out, err := svc.DownloadClients.Aria2GlobalStats(c.Request.Context(), clientID)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, out)
+	}
+}

internal/handler/downloads_extra.go

@@ -0,0 +1,117 @@
+// Package handler — pause/resume/organize on individual download tasks
+// and a thin sync-trigger surface used by the Vue UI's auto-sync toggle.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// downloadPauseHandler is a thin alias — the underlying qBittorrent
+// service exposes pause via the WebUI; we mark our local row too so
+// the React UI shows the right state on next refresh.
+func downloadPauseHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Model(&model.DownloadTask{}).
+			Where("id = ?", c.Param("id")).
+			Update("status", "paused").Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// downloadResumeHandler marks the row as queued so the next poll picks it up.
+func downloadResumeHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Model(&model.DownloadTask{}).
+			Where("id = ?", c.Param("id")).
+			Update("status", "queued").Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// downloadOrganizeOneHandler runs the file organizer for one task.
+// It looks up the task, then delegates to OrganizerService.OrganizePath().
+func downloadOrganizeOneHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var t model.DownloadTask
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Where("id = ?", c.Param("id")).First(&t).Error; err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "task not found"})
+			return
+		}
+		if t.SavePath == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "task has no save_path"})
+			return
+		}
+		// We don't have a per-path organizer right now; return the
+		// path the caller would scan. The general OrganizeAll endpoint
+		// (below) is the supported workflow.
+		c.JSON(http.StatusOK, gin.H{
+			"ok":   true,
+			"path": t.SavePath,
+			"note": "use POST /api/download/organize to bulk-organize",
+		})
+	}
+}
+
+// downloadOrganizeAllHandler triggers a bulk re-organize. This is a
+// thin wrapper that lists every saved path and delegates to the
+// existing OrganizerService for each library that contains those files.
+func downloadOrganizeAllHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Walk each library and re-organize. The OrganizerService is
+		// idempotent so this is safe to run repeatedly.
+		libs, err := svc.Repo.Library.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		results := make([]any, 0, len(libs))
+		for _, l := range libs {
+			res, err := svc.Organizer.OrganizeLibrary(c.Request.Context(), l.ID)
+			if err != nil {
+				results = append(results, gin.H{"library": l.Name, "error": err.Error()})
+				continue
+			}
+			results = append(results, gin.H{"library": l.Name, "result": res})
+		}
+		c.JSON(http.StatusOK, gin.H{"results": results})
+	}
+}
+
+// downloadSyncHandler triggers the qBittorrent reload + immediate poll.
+func downloadSyncHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Downloads.ReloadConfig(c.Request.Context()); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// downloadAutoSyncHandler is a no-op stub — the poll loop already runs
+// continuously. Returning 200 keeps the Vue UI's toggle happy.
+func downloadAutoSyncHandler(_ *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"ok": true, "auto_sync": true})
+	}
+}
+
+// downloadTasksAliasHandler is the alias used by the Vue UI; it
+// returns the same shape as listDownloadsHandler but at /download/tasks.
+func downloadTasksAliasHandler(svc *service.Container) gin.HandlerFunc {
+	return listDownloadsHandler(svc)
+}

internal/handler/handler.go

@@ -130,46 +130,156 @@ func Register(r *gin.Engine, cfg *config.Config, log *zap.Logger, svc *service.C
 			authed.POST("/duplicates/scan", middleware.AdminRequired(), detectDuplicatesHandler(svc))
 			authed.POST("/duplicates/unmark", middleware.AdminRequired(), unmarkDuplicatesHandler(svc))
 
-			// Recycle bin.
-			authed.GET("/recycle", middleware.AdminRequired(), listRecycleHandler(svc))
+		// Site management + cross-site torrent search (via SiteHandler).
+		siteHandler := NewSiteHandler(svc)
+		authed.GET("/sites", siteHandler.ListSites)
+		authed.GET("/sites/types", siteHandler.GetSiteTypes)
+		authed.GET("/sites/auth-types", siteHandler.GetAuthTypes)
+		authed.POST("/sites", middleware.AdminRequired(), siteHandler.CreateSite)
+		authed.GET("/sites/:id", siteHandler.GetSite)
+		authed.PUT("/sites/:id", middleware.AdminRequired(), siteHandler.UpdateSite)
+		authed.DELETE("/sites/:id", middleware.AdminRequired(), siteHandler.DeleteSite)
+		authed.POST("/sites/:id/test", middleware.AdminRequired(), siteHandler.TestSite)
+		authed.GET("/sites/search", siteSearchHandler(svc))
 
-			authed.GET("/ws", wsHandler(svc))
+		// Recycle bin.
+		authed.GET("/recycle", middleware.AdminRequired(), listRecycleHandler(svc))
 
-			// SSE event stream.
-			authed.GET("/events", sseHandler(svc))
+		authed.GET("/ws", wsHandler(svc))
 
-			// Download clients.
-			authed.GET("/download-clients", listDownloadClientsHandler(svc))
-			authed.POST("/download-clients", middleware.AdminRequired(), createDownloadClientHandler(svc))
-			authed.GET("/download-clients/:id", getDownloadClientHandler(svc))
-			authed.PUT("/download-clients/:id", middleware.AdminRequired(), updateDownloadClientHandler(svc))
-			authed.DELETE("/download-clients/:id", middleware.AdminRequired(), deleteDownloadClientHandler(svc))
-			authed.POST("/download-clients/:id/test", middleware.AdminRequired(), testDownloadClientHandler(svc))
+		// SSE event stream.
+		authed.GET("/events", sseHandler(svc))
 
-			// Notify channels.
-			authed.GET("/notify-channels", listNotifyChannelsHandler(svc))
-			authed.GET("/notify-channels/types", getNotifyChannelTypesHandler(svc))
-			authed.POST("/notify-channels", middleware.AdminRequired(), createNotifyChannelHandler(svc))
-			authed.GET("/notify-channels/:id", getNotifyChannelHandler(svc))
-			authed.PUT("/notify-channels/:id", middleware.AdminRequired(), updateNotifyChannelHandler(svc))
-			authed.DELETE("/notify-channels/:id", middleware.AdminRequired(), deleteNotifyChannelHandler(svc))
-			authed.POST("/notify-channels/:id/test", middleware.AdminRequired(), testNotifyChannelHandler(svc))
+		// Download clients.
+		authed.GET("/download-clients", listDownloadClientsHandler(svc))
+		authed.POST("/download-clients", middleware.AdminRequired(), createDownloadClientHandler(svc))
+		authed.GET("/download-clients/:id", getDownloadClientHandler(svc))
+		authed.PUT("/download-clients/:id", middleware.AdminRequired(), updateDownloadClientHandler(svc))
+		authed.DELETE("/download-clients/:id", middleware.AdminRequired(), deleteDownloadClientHandler(svc))
+		authed.POST("/download-clients/:id/test", middleware.AdminRequired(), testDownloadClientHandler(svc))
 
-			// Scheduler.
-			authed.GET("/scheduler/tasks", schedulerListTasksHandler(svc))
-			authed.POST("/scheduler/tasks/:id/run", middleware.AdminRequired(), schedulerRunTaskHandler(svc))
-			authed.GET("/scheduler/status", schedulerGetStatusHandler(svc))
+		// Notify channels.
+		authed.GET("/notify-channels", listNotifyChannelsHandler(svc))
+		authed.GET("/notify-channels/types", getNotifyChannelTypesHandler(svc))
+		authed.POST("/notify-channels", middleware.AdminRequired(), createNotifyChannelHandler(svc))
+		authed.GET("/notify-channels/:id", getNotifyChannelHandler(svc))
+		authed.PUT("/notify-channels/:id", middleware.AdminRequired(), updateNotifyChannelHandler(svc))
+		authed.DELETE("/notify-channels/:id", middleware.AdminRequired(), deleteNotifyChannelHandler(svc))
+		authed.POST("/notify-channels/:id/test", middleware.AdminRequired(), testNotifyChannelHandler(svc))
 
-			// Sites (PT 站点管理).
-			siteHandler := NewSiteHandler(svc)
-			authed.GET("/sites", siteHandler.ListSites)
-			authed.GET("/sites/types", siteHandler.GetSiteTypes)
-			authed.GET("/sites/auth-types", siteHandler.GetAuthTypes)
-			authed.POST("/sites", middleware.AdminRequired(), siteHandler.CreateSite)
-			authed.GET("/sites/:id", siteHandler.GetSite)
-			authed.PUT("/sites/:id", middleware.AdminRequired(), siteHandler.UpdateSite)
-			authed.DELETE("/sites/:id", middleware.AdminRequired(), siteHandler.DeleteSite)
-			authed.POST("/sites/:id/test", middleware.AdminRequired(), siteHandler.TestSite)
+		// Scheduler.
+		authed.GET("/scheduler/tasks", schedulerListTasksHandler(svc))
+		authed.POST("/scheduler/tasks/:id/run", middleware.AdminRequired(), schedulerRunTaskHandler(svc))
+		authed.GET("/scheduler/status", schedulerGetStatusHandler(svc))
+
+		// ── Auxiliary endpoints used by the React UI rails ──
+		authed.GET("/media/recent", recentMediaHandler(svc))
+		authed.GET("/media/stats", mediaStatsHandler(svc))
+
+		// Watch history (extra surface beyond /history).
+		authed.GET("/watch-history", historyListHandler(svc))
+		authed.GET("/watch-history/stats", historyStatsHandler(svc))
+		authed.GET("/watch-history/continue", historyContinueHandler(svc))
+		authed.DELETE("/watch-history", historyDeleteHandler(svc))
+		authed.DELETE("/watch-history/:id", historyDeleteOneHandler(svc))
+
+		// Multi-section TMDb feed used by DiscoverPage.
+		authed.GET("/discover/sections", discoverSectionsHandler(svc))
+		authed.GET("/discover/feed", discoverFeedHandler(svc))
+
+		// System metadata + read-only scheduler view.
+		authed.GET("/system/info", systemInfoHandler(svc))
+		authed.GET("/system/status", systemStatusHandler(svc))
+		authed.GET("/system/scheduler", systemSchedulerHandler(svc))
+
+		// Richer dashboard rails.
+		authed.GET("/stats/overview", statsOverviewHandler(svc))
+		authed.GET("/stats/trend", statsTrendHandler(svc))
+		authed.GET("/stats/top-content", statsTopContentHandler(svc))
+		authed.GET("/stats/libraries", statsLibrariesHandler(svc))
+		authed.GET("/stats/monitor", statsMonitorHandler(svc))
+
+		// Multi-persona play profiles (caller-scoped, admins via ?all=true).
+		authed.GET("/play-profiles", listPlayProfilesHandler(svc))
+		authed.POST("/play-profiles", createPlayProfileHandler(svc))
+		authed.PUT("/play-profiles/:id", updatePlayProfileHandler(svc))
+		authed.DELETE("/play-profiles/:id", deletePlayProfileHandler(svc))
+
+		// ── Search aliases ──
+		authed.GET("/search", searchUnifiedHandler(svc))
+		authed.GET("/search/advanced", searchAdvancedHandler(svc))
+		authed.GET("/search/tmdb", searchTMDbHandler(svc))
+		authed.GET("/search/sites", searchSitesHandler(svc))
+
+		// ── System extras ──
+		authed.GET("/system/config", listSystemConfigHandler(svc))
+		authed.GET("/settings/schema", schemaHandler(svc))
+		authed.GET("/system/events/ticket", systemEventsTicketHandler(svc))
+
+		// ── Per-user stats ──
+		authed.GET("/stats/user/:id", statsUserHandler(svc))
+		authed.GET("/stats/top-users", statsTopUsersHandler(svc))
+		authed.POST("/stats/play", statsPlayHandler(svc))
+
+		// ── Sites extras ──
+		authed.GET("/sites/:id/resource", siteResourceHandler(svc))
+		authed.GET("/sites/:id/userdata", siteUserdataHandler(svc))
+
+		// ── Subscription extras ──
+		authed.PUT("/subscriptions/:id", updateSubscriptionHandler(svc))
+		authed.POST("/subscriptions/:id/search", searchSubscriptionHandler(svc))
+
+		// ── Playlist extras ──
+		authed.POST("/playlists/:id/reorder", reorderPlaylistHandler(svc))
+		authed.DELETE("/playlists/:id/items/by-id/:item_id", deletePlaylistItemByIDHandler(svc))
+
+		// ── DLNA per-renderer control ──
+		authed.POST("/dlna/:uuid/play", dlnaPlayHandler(svc))
+		authed.POST("/dlna/:uuid/pause", dlnaPauseHandler(svc))
+		authed.POST("/dlna/:uuid/stop", dlnaStopHandler(svc))
+		authed.GET("/dlna/:uuid/status", dlnaStatusHandler(svc))
+
+		// ── Media favourite alias surface ──
+		authed.GET("/favorites", listFavoritesAliasHandler(svc))
+		authed.POST("/media/:id/favorite", addMediaFavoriteHandler(svc))
+		authed.DELETE("/media/:id/favorite", removeMediaFavoriteHandler(svc))
+		authed.GET("/media/:id/favorite/status", getMediaFavoriteStatusHandler(svc))
+		authed.POST("/media/:id/ai-scrape", aiScrapeMediaHandler(svc))
+		authed.POST("/media/scrape/test", scrapeTestHandler(svc))
+		authed.POST("/media/organize", middleware.AdminRequired(), organizeBulkHandler(svc))
+
+		// ── Playback metadata + external player handoff ──
+		authed.GET("/playback/:id/info", playbackInfoHandler(svc))
+		authed.POST("/playback/:id/progress", playbackProgressHandler(svc))
+		authed.GET("/playback/:id/external-players", externalPlayersHandler(svc))
+		authed.GET("/playback/:id/external-url", externalURLHandler(svc))
+		authed.GET("/playback/transcode/:job_id/status", transcodeStatusHandler(svc))
+
+		// ── Download task ops + sync triggers ──
+		authed.POST("/download/:id/pause", downloadPauseHandler(svc))
+		authed.POST("/download/:id/resume", downloadResumeHandler(svc))
+		authed.POST("/download/:id/organize", middleware.AdminRequired(), downloadOrganizeOneHandler(svc))
+		authed.POST("/download/organize", middleware.AdminRequired(), downloadOrganizeAllHandler(svc))
+		authed.POST("/download/sync", middleware.AdminRequired(), downloadSyncHandler(svc))
+		authed.POST("/download/start-auto-sync", middleware.AdminRequired(), downloadAutoSyncHandler(svc))
+		authed.GET("/download/tasks", downloadTasksAliasHandler(svc))
+		authed.POST("/download/add", addDownloadHandler(svc))
+
+		// ── License (anyone authenticated can activate / heartbeat) ──
+		authed.POST("/license/activate", licenseActivateHandler(svc))
+		authed.POST("/license/heartbeat", licenseHeartbeatHandler(svc))
+		authed.GET("/license/status", licenseStatusHandler(svc))
+		authed.GET("/license/heartbeat-status", licenseStatusHandler(svc))
+
+		// ── Assistant (multi-turn AI chat) ──
+		authed.GET("/admin/assistant/sessions", listAssistantSessionsHandler(svc))
+		authed.POST("/admin/assistant/sessions", createAssistantSessionHandler(svc))
+		authed.GET("/admin/assistant/session/:id", getAssistantSessionHandler(svc))
+		authed.DELETE("/admin/assistant/session/:id", deleteAssistantSessionHandler(svc))
+		authed.POST("/admin/assistant/chat", assistantChatHandler(svc))
+		authed.POST("/admin/assistant/execute", assistantExecuteHandler(svc))
+		authed.POST("/admin/assistant/undo/:op_id", assistantUndoHandler(svc))
+		authed.GET("/admin/assistant/history", assistantHistoryHandler(svc))
 		}
 
 		// Admin-only endpoints.
@@ -183,6 +293,35 @@ func Register(r *gin.Engine, cfg *config.Config, log *zap.Logger, svc *service.C
 			admin.PUT("/settings", updateSettingHandler(svc))
 			admin.GET("/logs", recentLogsHandler(svc))
 
+			// Permissions admin.
+			admin.GET("/users/:id/permissions", getUserPermissionsHandler(svc))
+			admin.PUT("/users/:id/permissions", updateUserPermissionsHandler(svc))
+			admin.POST("/users/:id/permissions/reset", resetUserPermissionsHandler(svc))
+
+			// Storage configs (Alist / S3 / WebDAV).
+			admin.GET("/storage/status", listStorageConfigsHandler(svc))
+			admin.GET("/storage/:type", getStorageConfigHandler(svc))
+			admin.PUT("/storage/:type", saveStorageConfigHandler(svc))
+			admin.POST("/storage/:type/test", testStorageConfigHandler(svc))
+
+			// Download client CRUD.
+			admin.GET("/download/clients", listDownloadClientsHandler(svc))
+			admin.POST("/download/clients", createDownloadClientHandler(svc))
+			admin.PUT("/download/clients/:id", updateDownloadClientHandler(svc))
+			admin.DELETE("/download/clients/:id", deleteDownloadClientHandler(svc))
+			admin.POST("/download/clients/:id/test", testDownloadClientHandler(svc))
+			admin.GET("/download/aria2/stats", aria2StatsHandler(svc))
+
+			// License generation / revocation.
+			admin.POST("/license/generate", licenseGenerateHandler(svc))
+			admin.GET("/license/list", licenseListHandler(svc))
+			admin.GET("/license/:id/activations", licenseListActivationsHandler(svc))
+			admin.POST("/license/activation/:id/unbind", licenseUnbindHandler(svc))
+			admin.POST("/license/:id/revoke", licenseRevokeHandler(svc))
+
+			// System scheduler trigger alias.
+			admin.POST("/system/scheduler/:name/trigger", schedulerTriggerHandler(svc))
+
 			// Database backup.
 			admin.GET("/backups", listBackupsHandler(svc))
 			admin.POST("/backups", createBackupHandler(svc))
@@ -192,6 +331,13 @@ func Register(r *gin.Engine, cfg *config.Config, log *zap.Logger, svc *service.C
 			// Notifications (test endpoint).
 			admin.POST("/notify/test", notifyTestHandler(svc))
 
+			// Notify channels CRUD + per-channel test.
+			admin.GET("/notify/channels", listNotifyChannelsHandler(svc))
+			admin.POST("/notify/channels", createNotifyChannelHandler(svc))
+			admin.PUT("/notify/channels/:id", updateNotifyChannelHandler(svc))
+			admin.DELETE("/notify/channels/:id", deleteNotifyChannelHandler(svc))
+			admin.POST("/notify/channels/:id/test", testNotifyChannelHandler(svc))
+
 			// File organizer.
 			admin.POST("/media/:id/organize", organizeMediaHandler(svc))
 			admin.POST("/libraries/:id/organize", organizeLibraryHandler(svc))

internal/handler/license.go

@@ -0,0 +1,145 @@
+// Package handler — license key endpoints.
+package handler
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+type generateKeyReq struct {
+	Customer       string `json:"customer"`
+	Plan           string `json:"plan"`
+	MaxActivations int    `json:"max_activations"`
+	ExpiresAt      string `json:"expires_at,omitempty"` // RFC3339, "" = perpetual
+	Notes          string `json:"notes,omitempty"`
+}
+
+func licenseGenerateHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req generateKeyReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		var expires *time.Time
+		if req.ExpiresAt != "" {
+			t, err := time.Parse(time.RFC3339, req.ExpiresAt)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{"error": "expires_at must be RFC3339"})
+				return
+			}
+			expires = &t
+		}
+		k, err := svc.License.Generate(
+			c.Request.Context(),
+			req.Customer, req.Plan, req.Notes,
+			req.MaxActivations, expires,
+		)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, k)
+	}
+}
+
+func licenseListHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.License.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+type activateReq struct {
+	Key        string `json:"key" binding:"required"`
+	DeviceID   string `json:"device_id" binding:"required"`
+	DeviceName string `json:"device_name"`
+}
+
+func licenseActivateHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req activateReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		a, err := svc.License.Activate(
+			c.Request.Context(), req.Key, req.DeviceID, req.DeviceName, c.ClientIP(),
+		)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, a)
+	}
+}
+
+func licenseListActivationsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.License.ListActivations(c.Request.Context(), c.Param("id"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+func licenseUnbindHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.License.Unbind(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+func licenseRevokeHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.License.Revoke(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+func licenseHeartbeatHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		actID := c.Query("activation_id")
+		if actID == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "activation_id required"})
+			return
+		}
+		if err := svc.License.Heartbeat(c.Request.Context(), actID); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+func licenseStatusHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keyID := c.Query("key_id")
+		if keyID == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "key_id required"})
+			return
+		}
+		out, err := svc.License.Status(c.Request.Context(), keyID)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, out)
+	}
+}

internal/handler/media_extra.go

@@ -0,0 +1,70 @@
+// Package handler — auxiliary media endpoints used by the home page
+// rails (recent additions) and the admin dashboard summary card.
+package handler
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func recentMediaHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "12"))
+		if limit <= 0 || limit > 100 {
+			limit = 12
+		}
+		var items []model.Media
+		if err := svc.Repo.DB.Order("created_at desc").Limit(limit).Find(&items).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, items)
+	}
+}
+
+func mediaStatsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var totals struct {
+			Movies   int64 `json:"movies"`
+			TV       int64 `json:"tv"`
+			Anime    int64 `json:"anime"`
+			Music    int64 `json:"music"`
+			Unscaped int64 `json:"unscraped"`
+		}
+		// Per-library type rolls up to per-media-type via the JOIN.
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Joins("JOIN libraries ON libraries.id = media.library_id").
+			Where("libraries.type = ?", "movie").Count(&totals.Movies).Error
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Joins("JOIN libraries ON libraries.id = media.library_id").
+			Where("libraries.type = ?", "tv").Count(&totals.TV).Error
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Joins("JOIN libraries ON libraries.id = media.library_id").
+			Where("libraries.type = ?", "anime").Count(&totals.Anime).Error
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Joins("JOIN libraries ON libraries.id = media.library_id").
+			Where("libraries.type = ?", "music").Count(&totals.Music).Error
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Where("scrape_status IS NULL OR scrape_status = '' OR scrape_status = 'pending'").
+			Count(&totals.Unscaped).Error
+
+		var totalCount, totalSize, totalSeconds int64
+		_ = svc.Repo.DB.Model(&model.Media{}).Count(&totalCount).Error
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Select("COALESCE(SUM(size_bytes),0)").Row().Scan(&totalSize)
+		_ = svc.Repo.DB.Model(&model.Media{}).
+			Select("COALESCE(SUM(duration_sec),0)").Row().Scan(&totalSeconds)
+
+		c.JSON(http.StatusOK, gin.H{
+			"by_type":       totals,
+			"total":         totalCount,
+			"total_size":    totalSize,
+			"total_seconds": totalSeconds,
+		})
+	}
+}

internal/handler/media_favorite.go

@@ -0,0 +1,141 @@
+// Package handler — alias endpoints used by the Vue UI's media detail
+// page that map onto the existing /favourites surface.
+//
+//	POST   /media/:id/favorite        → add to favourites
+//	DELETE /media/:id/favorite        → remove from favourites
+//	GET    /media/:id/favorite/status → boolean
+//	GET    /favorites                 → alias of /favourites
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// addMediaFavoriteHandler ensures the (user, media) row exists. If it
+// already does we return 200 with favourite=true so the call is
+// idempotent — different from the Toggle behaviour.
+func addMediaFavoriteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		// Check current state.
+		var existing model.Favorite
+		err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Where("user_id = ? AND media_id = ?", uid, c.Param("id")).
+			First(&existing).Error
+		if err == nil {
+			c.JSON(http.StatusOK, gin.H{"favourite": true})
+			return
+		}
+		// Otherwise create.
+		fav := &model.Favorite{UserID: toString(uid), MediaID: c.Param("id")}
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).Create(fav).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"favourite": true})
+	}
+}
+
+// removeMediaFavoriteHandler is the idempotent inverse.
+func removeMediaFavoriteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Where("user_id = ? AND media_id = ?", uid, c.Param("id")).
+			Delete(&model.Favorite{}).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"favourite": false})
+	}
+}
+
+// getMediaFavoriteStatusHandler returns the current state.
+func getMediaFavoriteStatusHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		var n int64
+		_ = svc.Repo.DB.WithContext(c.Request.Context()).
+			Model(&model.Favorite{}).
+			Where("user_id = ? AND media_id = ?", uid, c.Param("id")).
+			Count(&n).Error
+		c.JSON(http.StatusOK, gin.H{"favourite": n > 0})
+	}
+}
+
+// listFavoritesAliasHandler is the /favorites alias of /favourites.
+// We reuse the existing service method.
+func listFavoritesAliasHandler(svc *service.Container) gin.HandlerFunc {
+	return listFavouritesHandler(svc)
+}
+
+// aiScrapeMediaHandler asks the scraper to enrich one media row using
+// AI-assisted matching. Today we just delegate to the existing scrape
+// path; the AI hint comes from svc.AI when configured.
+func aiScrapeMediaHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		m, err := svc.Repo.Media.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil || m == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "media not found"})
+			return
+		}
+		if err := svc.Scraper.EnrichOne(c.Request.Context(), m); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, m)
+	}
+}
+
+// scrapeTestHandler validates a (provider, code) pair without touching
+// the database.  Useful for the "preview" workflow in the Vue UI.
+type scrapeTestReq struct {
+	Code string `json:"code" binding:"required"`
+}
+
+func scrapeTestHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req scrapeTestReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		// Try TMDb first; the upstream chain handles fall-back to
+		// Bangumi/TheTVDB when configured.
+		match, err := svc.TMDb.SearchMovie(c.Request.Context(), req.Code, 0)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"match": match})
+	}
+}
+
+// organizeBulkHandler triggers organisation across every library when
+// the caller hits POST /media/organize without a media id. It mirrors
+// the upstream Vue surface.
+func organizeBulkHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		libs, err := svc.Repo.Library.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		out := make([]any, 0, len(libs))
+		for _, l := range libs {
+			res, err := svc.Organizer.OrganizeLibrary(c.Request.Context(), l.ID)
+			if err != nil {
+				out = append(out, gin.H{"library": l.Name, "error": err.Error()})
+				continue
+			}
+			out = append(out, gin.H{"library": l.Name, "result": res})
+		}
+		c.JSON(http.StatusOK, gin.H{"results": out})
+	}
+}

internal/handler/notify_channels.go

@@ -0,0 +1,73 @@
+// Package handler — notify channel CRUD + per-channel test endpoint.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func listNotifyChannelsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.NotifyChannels.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+func createNotifyChannelHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.ChannelInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		row, err := svc.NotifyChannels.Create(c.Request.Context(), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func updateNotifyChannelHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.ChannelInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		row, err := svc.NotifyChannels.Update(c.Request.Context(), c.Param("id"), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func deleteNotifyChannelHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.NotifyChannels.Delete(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+func testNotifyChannelHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.NotifyChannels.Test(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"message": "test sent"})
+	}
+}

internal/handler/permissions.go

@@ -0,0 +1,74 @@
+// Package handler — per-user feature toggle endpoints.
+//
+//	GET /auth/permissions          → caller's effective permissions
+//	GET /admin/users/:id/permissions
+//	PUT /admin/users/:id/permissions
+//	POST /admin/users/:id/permissions/reset
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func myPermissionsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		row, err := svc.Permissions.Effective(c.Request.Context(), toString(uid))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		if row == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func getUserPermissionsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		row, err := svc.Permissions.Effective(c.Request.Context(), c.Param("id"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		if row == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func updateUserPermissionsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var p model.UserPermission
+		if err := c.ShouldBindJSON(&p); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		if err := svc.Permissions.Save(c.Request.Context(), c.Param("id"), &p); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, p)
+	}
+}
+
+func resetUserPermissionsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		row, err := svc.Permissions.Reset(c.Request.Context(), c.Param("id"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}

internal/handler/play_profile.go

@@ -0,0 +1,86 @@
+// Package handler — multi-persona play profile CRUD endpoints.
+//
+// Non-admin users see / mutate only their own profiles. Admins see
+// every profile so they can manage child accounts, etc.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// listPlayProfilesHandler returns the caller's profiles, or every
+// profile when the caller is an admin AND ?all=true is set.
+func listPlayProfilesHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		if c.Query("all") == "true" && role == "admin" {
+			rows, err := svc.PlayProfiles.List(c.Request.Context())
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+				return
+			}
+			c.JSON(http.StatusOK, rows)
+			return
+		}
+		rows, err := svc.PlayProfiles.ListByUser(c.Request.Context(), toString(uid))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, rows)
+	}
+}
+
+func createPlayProfileHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.PlayProfileInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		// Default the user_id to the caller; admins can override.
+		uid, _ := c.Get(middleware.CtxUserID)
+		role, _ := c.Get(middleware.CtxUserRole)
+		if in.UserID == "" || role != "admin" {
+			in.UserID = toString(uid)
+		}
+		row, err := svc.PlayProfiles.Create(c.Request.Context(), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func updatePlayProfileHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.PlayProfileInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		row, err := svc.PlayProfiles.Update(c.Request.Context(), c.Param("id"), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+func deletePlayProfileHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.PlayProfiles.Delete(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}

internal/handler/playback_extra.go

@@ -0,0 +1,130 @@
+// Package handler — playback metadata endpoints expected by the Vue UI:
+//
+//	GET  /playback/:id/info
+//	POST /playback/:id/progress
+//	GET  /playback/:id/external-players
+//	GET  /playback/:id/external-url
+//	GET  /playback/transcode/:job_id/status
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// playbackInfoHandler returns the media row + a `stream_url` the React
+// player can hit. Mirrors the Python project's surface.
+func playbackInfoHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		m, err := svc.Repo.Media.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil || m == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "media not found"})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"media":       m,
+			"stream_url":  "/api/stream/" + m.ID,
+			"hls_url":     "/api/hls/" + m.ID + "/index.m3u8",
+		})
+	}
+}
+
+type playbackProgressReq struct {
+	PositionMs int64 `json:"position_ms"`
+	DurationMs int64 `json:"duration_ms"`
+	Completed  bool  `json:"completed"`
+}
+
+func playbackProgressHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req playbackProgressReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		uid, _ := c.Get(middleware.CtxUserID)
+		if err := svc.Playback.RecordProgress(
+			c.Request.Context(), toString(uid), c.Param("id"),
+			req.PositionMs, req.DurationMs,
+		); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+// externalPlayersHandler returns the list of external player URI
+// schemes the UI can offer the user. We lookup the media row to
+// produce the per-player launch URL.
+func externalPlayersHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		m, err := svc.Repo.Media.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil || m == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "media not found"})
+			return
+		}
+		streamURL := "/api/stream/" + m.ID
+		c.JSON(http.StatusOK, gin.H{
+			"players": []gin.H{
+				{"name": "VLC", "scheme": "vlc://", "url": "vlc://" + streamURL},
+				{"name": "PotPlayer", "scheme": "potplayer://", "url": "potplayer://" + streamURL},
+				{"name": "MX Player", "scheme": "intent://", "url": "intent://" + streamURL + "#Intent;package=com.mxtech.videoplayer.ad;end"},
+				{"name": "IINA", "scheme": "iina://", "url": "iina://weblink?url=" + streamURL},
+				{"name": "nPlayer", "scheme": "nplayer-", "url": "nplayer-" + streamURL},
+			},
+		})
+	}
+}
+
+// externalURLHandler returns just the raw stream URL plus the auth
+// token query string the external player needs.
+func externalURLHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		m, err := svc.Repo.Media.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil || m == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "media not found"})
+			return
+		}
+		// Re-issue a short-lived token for this stream.
+		uid, _ := c.Get(middleware.CtxUserID)
+		u, err := svc.Repo.User.FindByID(c.Request.Context(), toString(uid))
+		if err != nil || u == nil {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "user not found"})
+			return
+		}
+		token, err := svc.Auth.IssueToken(u)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"url":   "/api/stream/" + m.ID + "?token=" + token,
+			"token": token,
+		})
+	}
+}
+
+// transcodeStatusHandler reports the live status of one transcode job.
+// We surface the active jobs the transcoder knows about.
+func transcodeStatusHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		jobID := c.Param("job_id")
+		for _, j := range svc.Transcoder.Active() {
+			if j.MediaID == jobID {
+				c.JSON(http.StatusOK, gin.H{"job_id": jobID, "status": "running", "job": j})
+				return
+			}
+		}
+		c.JSON(http.StatusOK, gin.H{"job_id": jobID, "status": "idle"})
+	}
+}
+
+// _ keeps imports tidy when the model package isn't otherwise used.
+var _ = model.Media{}
+var _ = service.Container{}

internal/handler/playlist_extra.go

@@ -0,0 +1,55 @@
+// Package handler — playlist reordering + per-item-id removal that the
+// Vue UI uses on top of the basic /playlists/:id/items surface.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+type reorderReq struct {
+	// Order is a list of media IDs in the desired playback order.
+	Order []string `json:"order" binding:"required"`
+}
+
+// reorderPlaylistHandler updates the Position column on each
+// PlaylistItem to match the supplied order. Items missing from the
+// order keep their existing position.
+func reorderPlaylistHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req reorderReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		pid := c.Param("id")
+		for i, mid := range req.Order {
+			if err := svc.Repo.DB.WithContext(c.Request.Context()).
+				Model(&model.PlaylistItem{}).
+				Where("playlist_id = ? AND media_id = ?", pid, mid).
+				Update("position", i).Error; err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+				return
+			}
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+// deletePlaylistItemByIDHandler is the alternate route at
+// /playlists/:id/items/:item_id (vs. the existing /:media_id variant).
+func deletePlaylistItemByIDHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Where("playlist_id = ? AND id = ?", c.Param("id"), c.Param("item_id")).
+			Delete(&model.PlaylistItem{}).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}

internal/handler/search_extra.go

@@ -0,0 +1,106 @@
+// Package handler — unified search surface that mirrors the Python
+// project's /api/search* endpoints. Internally we delegate to the
+// existing media + site adapters; advanced/tmdb/sites variants exist
+// so the upstream Vue UI's queries don't need rewriting.
+package handler
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// searchUnifiedHandler is the basic /api/search endpoint.
+func searchUnifiedHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		q := c.Query("q")
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "30"))
+		if limit <= 0 || limit > 200 {
+			limit = 30
+		}
+		items, err := svc.Media.SearchMedia(c.Request.Context(), q, limit)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": items, "total": len(items)})
+	}
+}
+
+// searchAdvancedHandler accepts query + optional filters
+// (year, type, library_id) — currently it ignores the filters in the
+// SQL but threads them through to the response so the UI can echo
+// them back. This keeps API parity without a giant query builder.
+func searchAdvancedHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		q := c.Query("q")
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "30"))
+		if limit <= 0 || limit > 200 {
+			limit = 30
+		}
+		items, err := svc.Media.SearchMedia(c.Request.Context(), q, limit)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"items":   items,
+			"filters": gin.H{
+				"year":       c.Query("year"),
+				"type":       c.Query("type"),
+				"library_id": c.Query("library_id"),
+			},
+		})
+	}
+}
+
+// searchTMDbHandler proxies the TMDb /search endpoint via the existing
+// SearchMovie helper. Movies and TV use different URLs upstream but
+// only the movie path is wired today; TV is best-effort.
+func searchTMDbHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		q := c.Query("query")
+		if q == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "query required"})
+			return
+		}
+		if svc.TMDb == nil || !svc.TMDb.Enabled() {
+			c.JSON(http.StatusOK, gin.H{"items": []any{}, "note": "tmdb disabled"})
+			return
+		}
+		match, err := svc.TMDb.SearchMovie(c.Request.Context(), q, 0)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		out := make([]any, 0, 1)
+		if match != nil {
+			out = append(out, match)
+		}
+		c.JSON(http.StatusOK, gin.H{"items": out})
+	}
+}
+
+// searchSitesHandler mirrors the existing /sites/search but at the
+// /search/sites alias the Vue UI uses.
+func searchSitesHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keyword := c.Query("keyword")
+		if keyword == "" {
+			keyword = c.Query("q")
+		}
+		if keyword == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "keyword required"})
+			return
+		}
+		results, err := svc.Site.Search(c.Request.Context(), keyword)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": results})
+	}
+}

internal/handler/sites.go

@@ -0,0 +1,148 @@
+// Package handler — site management (PT/BT tracker CRUD + cross-site search).
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// ─── CRUD ────────────────────────────────────────────────────────────────────
+
+func listSitesHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		sites, err := svc.Site.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": sites})
+	}
+}
+
+func getSiteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		site, err := svc.Site.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		if site == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "not found"})
+			return
+		}
+		c.JSON(http.StatusOK, site)
+	}
+}
+
+type createSiteReq struct {
+	Name       string `json:"name" binding:"required"`
+	BaseURL    string `json:"base_url" binding:"required"`
+	SiteType   string `json:"site_type"`
+	AuthType   string `json:"auth_type"`
+	Cookie     string `json:"cookie"`
+	APIKey     string `json:"api_key"`
+	AuthHeader string `json:"auth_header"`
+	UserAgent  string `json:"user_agent"`
+	RSSURL     string `json:"rss_url"`
+	Timeout    int    `json:"timeout"`
+	Priority   int    `json:"priority"`
+	UseProxy   bool   `json:"use_proxy"`
+	Enabled    *bool  `json:"enabled"`
+	Downloader string `json:"downloader"`
+}
+
+func createSiteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req createSiteReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		enabled := true
+		if req.Enabled != nil {
+			enabled = *req.Enabled
+		}
+		site := &model.Site{
+			Name:       req.Name,
+			BaseURL:    req.BaseURL,
+			SiteType:   req.SiteType,
+			AuthType:   req.AuthType,
+			Cookie:     req.Cookie,
+			APIKey:     req.APIKey,
+			AuthHeader: req.AuthHeader,
+			UserAgent:  req.UserAgent,
+			RSSURL:     req.RSSURL,
+			Timeout:    req.Timeout,
+			Priority:   req.Priority,
+			UseProxy:   req.UseProxy,
+			Enabled:    enabled,
+			Downloader: req.Downloader,
+		}
+		if err := svc.Site.Create(c.Request.Context(), site); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, site)
+	}
+}
+
+func updateSiteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var patch map[string]any
+		if err := c.ShouldBindJSON(&patch); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		if err := svc.Site.Update(c.Request.Context(), c.Param("id"), patch); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		// Return the updated row.
+		site, _ := svc.Site.FindByID(c.Request.Context(), c.Param("id"))
+		c.JSON(http.StatusOK, site)
+	}
+}
+
+func deleteSiteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Site.Delete(c.Request.Context(), c.Param("id")); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+// ─── Connection test ─────────────────────────────────────────────────────────
+
+func testSiteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		ok, msg, err := svc.Site.TestConnection(c.Request.Context(), c.Param("id"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"success": ok, "message": msg})
+	}
+}
+
+// ─── Cross-site search ───────────────────────────────────────────────────────
+
+func siteSearchHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keyword := c.Query("keyword")
+		if keyword == "" {
+			keyword = c.Query("q")
+		}
+		results, err := svc.Site.Search(c.Request.Context(), keyword)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": results, "total": len(results)})
+	}
+}

internal/handler/sites_extra.go

@@ -0,0 +1,61 @@
+// Package handler — extra site endpoints used by the Vue UI:
+//
+//	GET /sites/:id/resource → keyword search scoped to one site
+//	GET /sites/:id/userdata → cookie-derived user info (stubbed)
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// siteResourceHandler runs a search restricted to a single site.
+//
+// We reuse the full SiteService.Search() and post-filter by site_id;
+// it's not the hottest path so we trade simplicity for speed here.
+func siteResourceHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keyword := c.Query("keyword")
+		if keyword == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "keyword required"})
+			return
+		}
+		all, err := svc.Site.Search(c.Request.Context(), keyword)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		want := c.Param("id")
+		filtered := make([]service.SearchResult, 0, len(all))
+		for _, r := range all {
+			if r.SiteID == want {
+				filtered = append(filtered, r)
+			}
+		}
+		c.JSON(http.StatusOK, gin.H{"items": filtered})
+	}
+}
+
+// siteUserdataHandler returns whatever the site exposes about the
+// authenticated user (upload/download stats, ratio, etc.). This is a
+// stub: we report the cookie length so the UI can confirm a login is
+// present, but full per-site parsing is out of scope here.
+func siteUserdataHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		s, err := svc.Site.FindByID(c.Request.Context(), c.Param("id"))
+		if err != nil || s == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "site not found"})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"site_id":      s.ID,
+			"name":         s.Name,
+			"cookie_set":   len(s.Cookie) > 0,
+			"login_status": s.LoginStatus,
+			"note":         "userdata parsing not implemented; stub",
+		})
+	}
+}

internal/handler/stats_extra.go

@@ -0,0 +1,155 @@
+// Package handler — richer dashboard statistics endpoints.
+//
+// /api/stats already returns the basic snapshot. The Vue admin
+// dashboard also uses:
+//
+//   /api/stats/overview      — counts + total size + total seconds
+//   /api/stats/trend         — daily play count over last N days
+//   /api/stats/top-content   — top played media (by play count)
+//   /api/stats/libraries     — per-library item count + size
+//   /api/stats/monitor       — live CPU/mem/disk
+package handler
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+func statsOverviewHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		snap, err := svc.Stats.Compute(c.Request.Context(), svc.Cfg.App.DataDir)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{
+			"libraries":     snap.Libraries,
+			"media_count":   snap.MediaCount,
+			"users_count":   snap.UsersCount,
+			"total_size":    snap.TotalSizeBytes,
+			"total_seconds": snap.TotalSeconds,
+			"generated_at":  snap.GeneratedAt,
+		})
+	}
+}
+
+// statsTrendHandler returns play counts per day for the last N days.
+func statsTrendHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		days, _ := strconv.Atoi(c.DefaultQuery("days", "14"))
+		if days <= 0 || days > 90 {
+			days = 14
+		}
+		// Use the playback_history table; one row per (user, media)
+		// per day if we group by date(watched_at).
+		type bucket struct {
+			Day   string `json:"day"`
+			Count int64  `json:"count"`
+		}
+		out := make([]bucket, 0, days)
+		now := time.Now().UTC()
+		for i := days - 1; i >= 0; i-- {
+			start := now.AddDate(0, 0, -i).Truncate(24 * time.Hour)
+			end := start.Add(24 * time.Hour)
+			var n int64
+			_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+				Where("watched_at >= ? AND watched_at < ?", start, end).
+				Count(&n).Error
+			out = append(out, bucket{
+				Day:   start.Format("2006-01-02"),
+				Count: n,
+			})
+		}
+		c.JSON(http.StatusOK, gin.H{"trend": out, "days": days})
+	}
+}
+
+// statsTopContentHandler returns the most-watched media items.
+func statsTopContentHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
+		if limit <= 0 || limit > 50 {
+			limit = 10
+		}
+		type row struct {
+			MediaID    string `json:"media_id"`
+			PlayCount  int64  `json:"play_count"`
+			LastPlayed time.Time `json:"last_played"`
+		}
+		var rows []row
+		_ = svc.Repo.DB.Table("playback_histories").
+			Select("media_id, COUNT(*) as play_count, MAX(watched_at) as last_played").
+			Group("media_id").
+			Order("play_count desc").
+			Limit(limit).
+			Scan(&rows).Error
+		// Hydrate media titles in a single query.
+		ids := make([]string, 0, len(rows))
+		for _, r := range rows {
+			ids = append(ids, r.MediaID)
+		}
+		mIdx := map[string]model.Media{}
+		if len(ids) > 0 {
+			var media []model.Media
+			_ = svc.Repo.DB.Where("id IN ?", ids).Find(&media).Error
+			for _, m := range media {
+				mIdx[m.ID] = m
+			}
+		}
+		out := make([]gin.H, 0, len(rows))
+		for _, r := range rows {
+			out = append(out, gin.H{
+				"media":       mIdx[r.MediaID],
+				"play_count":  r.PlayCount,
+				"last_played": r.LastPlayed,
+			})
+		}
+		c.JSON(http.StatusOK, gin.H{"items": out})
+	}
+}
+
+// statsLibrariesHandler returns per-library counts + size.
+func statsLibrariesHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var libs []model.Library
+		if err := svc.Repo.DB.Find(&libs).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		out := make([]gin.H, 0, len(libs))
+		for _, l := range libs {
+			var count int64
+			var size int64
+			_ = svc.Repo.DB.Model(&model.Media{}).
+				Where("library_id = ?", l.ID).Count(&count).Error
+			_ = svc.Repo.DB.Model(&model.Media{}).
+				Where("library_id = ?", l.ID).
+				Select("COALESCE(SUM(size_bytes),0)").Row().Scan(&size)
+			out = append(out, gin.H{
+				"library":    l,
+				"item_count": count,
+				"total_size": size,
+			})
+		}
+		c.JSON(http.StatusOK, gin.H{"libraries": out})
+	}
+}
+
+// statsMonitorHandler returns live system resource usage; this is just
+// the Hardware portion of the snapshot but with a snappy schema.
+func statsMonitorHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		snap, err := svc.Stats.Compute(c.Request.Context(), svc.Cfg.App.DataDir)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, snap.Hardware)
+	}
+}

internal/handler/stats_user.go

@@ -0,0 +1,111 @@
+// Package handler — per-user stats and a play-event recorder.
+package handler
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// statsUserHandler returns a watch-time summary for one user.
+func statsUserHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid := c.Param("id")
+		var watched int64
+		_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ?", uid).
+			Select("COALESCE(SUM(position_ms), 0)").
+			Row().Scan(&watched)
+		var total int64
+		_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ?", uid).Count(&total).Error
+		c.JSON(http.StatusOK, gin.H{
+			"user_id":      uid,
+			"watched_ms":   watched,
+			"plays":        total,
+			"watched_hours": float64(watched) / 1000.0 / 3600.0,
+		})
+	}
+}
+
+// statsTopUsersHandler returns the most active users by play count.
+func statsTopUsersHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
+		if limit <= 0 || limit > 50 {
+			limit = 10
+		}
+		type row struct {
+			UserID string `json:"user_id"`
+			Plays  int64  `json:"plays"`
+		}
+		var rows []row
+		_ = svc.Repo.DB.Table("playback_histories").
+			Select("user_id, COUNT(*) as plays").
+			Group("user_id").
+			Order("plays desc").
+			Limit(limit).Scan(&rows).Error
+		// Hydrate usernames in one query.
+		ids := make([]string, 0, len(rows))
+		for _, r := range rows {
+			ids = append(ids, r.UserID)
+		}
+		nameIdx := map[string]string{}
+		if len(ids) > 0 {
+			var users []model.User
+			_ = svc.Repo.DB.Where("id IN ?", ids).Find(&users).Error
+			for _, u := range users {
+				nameIdx[u.ID] = u.Username
+			}
+		}
+		out := make([]gin.H, 0, len(rows))
+		for _, r := range rows {
+			out = append(out, gin.H{
+				"user_id":  r.UserID,
+				"username": nameIdx[r.UserID],
+				"plays":    r.Plays,
+			})
+		}
+		c.JSON(http.StatusOK, gin.H{"items": out})
+	}
+}
+
+// statsPlayHandler accepts a play event so the Vue analytics panel can
+// emit one even when the actual progress write goes through /history.
+type playEventReq struct {
+	MediaID    string `json:"media_id" binding:"required"`
+	PositionMs int64  `json:"position_ms"`
+	DurationMs int64  `json:"duration_ms"`
+	Completed  bool   `json:"completed"`
+}
+
+func statsPlayHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req playEventReq
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		uid, _ := c.Get(middleware.CtxUserID)
+		// Just upsert into PlaybackHistory; the existing service
+		// handles the dedup logic.
+		if err := svc.Repo.History.Upsert(c.Request.Context(), &model.PlaybackHistory{
+			UserID:     toString(uid),
+			MediaID:    req.MediaID,
+			PositionMs: req.PositionMs,
+			DurationMs: req.DurationMs,
+			WatchedAt:  time.Now(),
+			Completed:  req.Completed,
+		}); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}

internal/handler/storage_config.go

@@ -0,0 +1,75 @@
+// Package handler — Alist / S3 / WebDAV storage config endpoints.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// listStorageConfigsHandler returns the status overview used by the
+// admin storage panel: every persisted backend with secrets redacted.
+func listStorageConfigsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.StorageCfg.List(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": rows})
+	}
+}
+
+// getStorageConfigHandler returns one config (with the decrypted body).
+func getStorageConfigHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		row, err := svc.StorageCfg.Get(c.Request.Context(), c.Param("type"))
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		if row == nil {
+			c.JSON(http.StatusOK, gin.H{"type": c.Param("type"), "config": gin.H{}})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+// saveStorageConfigHandler upserts the config row; the caller passes
+// the type via URL and the body as a JSON object.
+func saveStorageConfigHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.StorageInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		in.Type = c.Param("type")
+		row, err := svc.StorageCfg.Save(c.Request.Context(), in)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, row)
+	}
+}
+
+// testStorageConfigHandler probes an unsaved config.
+func testStorageConfigHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var in service.StorageInput
+		if err := c.ShouldBindJSON(&in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		in.Type = c.Param("type")
+		if err := svc.StorageCfg.Test(c.Request.Context(), in); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"ok": false, "error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}

internal/handler/subscription_extra.go

@@ -0,0 +1,61 @@
+// Package handler — subscription update + per-subscription site search.
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// updateSubscriptionHandler patches a subscription row.
+func updateSubscriptionHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var patch model.Subscription
+		if err := c.ShouldBindJSON(&patch); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		if err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Model(&model.Subscription{}).
+			Where("id = ?", c.Param("id")).
+			Updates(map[string]any{
+				"name":     patch.Name,
+				"feed_url": patch.FeedURL,
+				"filter":   patch.Filter,
+				"enabled":  patch.Enabled,
+			}).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+// searchSubscriptionHandler runs a one-off keyword search against the
+// configured tracker sites for the given subscription. We treat the
+// subscription's filter as the search term; this lets the UI preview
+// what would be queued without actually downloading anything.
+func searchSubscriptionHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var sub model.Subscription
+		err := svc.Repo.DB.WithContext(c.Request.Context()).
+			Where("id = ?", c.Param("id")).First(&sub).Error
+		if err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "subscription not found"})
+			return
+		}
+		keyword := sub.Filter
+		if keyword == "" {
+			keyword = sub.Name
+		}
+		results, err := svc.Site.Search(c.Request.Context(), keyword)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"items": results, "subscription": sub})
+	}
+}

internal/handler/system_extra.go

@@ -0,0 +1,159 @@
+// Package handler — system config + scheduler trigger + events ticket.
+package handler
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// listSystemConfigHandler is the non-admin alias for /admin/settings.
+// It returns the same key/value rows so the Vue UI's `system.getConfig`
+// helper keeps working.
+func listSystemConfigHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := svc.Repo.Setting.All(c.Request.Context())
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		// Hide secret-flavoured keys for non-admins.
+		role, _ := c.Get(middleware.CtxUserRole)
+		out := make([]model.Setting, 0, len(rows))
+		for _, s := range rows {
+			if role != "admin" && isSecretKey(s.Key) {
+				s.Value = "********"
+			}
+			out = append(out, s)
+		}
+		c.JSON(http.StatusOK, gin.H{"items": out})
+	}
+}
+
+func isSecretKey(k string) bool {
+	for _, suffix := range []string{".token", ".secret", ".password", ".api_key", ".cookie"} {
+		if endsWith(k, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func endsWith(s, suffix string) bool {
+	return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix
+}
+
+// schemaHandler returns the curated settings schema (used by the
+// `getSchema()` Vue helper). It mirrors the SettingsPage groupings but
+// in JSON so the upstream UI can render its dynamic form.
+func schemaHandler(_ *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"groups": []gin.H{
+				{
+					"key":   "general",
+					"label": "常规",
+					"items": []gin.H{
+						{"key": "tmdb.language", "type": "select", "label": "TMDb 元数据语言"},
+						{"key": "transcode.enabled", "type": "toggle", "label": "启用转码"},
+						{"key": "transcode.hw_accel", "type": "select", "label": "硬件加速"},
+						{"key": "transcode.max_jobs", "type": "number", "label": "最大并发"},
+						{"key": "ffmpeg.path", "type": "text", "label": "FFmpeg 路径"},
+						{"key": "ffprobe.path", "type": "text", "label": "FFprobe 路径"},
+					},
+				},
+				{
+					"key":   "organize",
+					"label": "整理 & 刮削",
+					"items": []gin.H{
+						{"key": "organize.auto", "type": "toggle"},
+						{"key": "organize.movie_format", "type": "text"},
+						{"key": "organize.tv_format", "type": "text"},
+						{"key": "organize.anime_format", "type": "text"},
+						{"key": "scrape.auto_on_scan", "type": "toggle"},
+						{"key": "scrape.providers", "type": "text"},
+						{"key": "scrape.language", "type": "text"},
+					},
+				},
+				{
+					"key":   "adult",
+					"label": "Adult / NSFW",
+					"items": []gin.H{
+						{"key": "adult.enabled", "type": "toggle"},
+						{"key": "adult.require_pin", "type": "toggle"},
+						{"key": "adult.pin", "type": "text"},
+					},
+				},
+				{
+					"key":   "qbittorrent",
+					"label": "qBittorrent",
+					"items": []gin.H{
+						{"key": "qbittorrent.url", "type": "text"},
+						{"key": "qbittorrent.username", "type": "text"},
+						{"key": "qbittorrent.password", "type": "text"},
+						{"key": "qbittorrent.savepath", "type": "text"},
+					},
+				},
+			},
+		})
+	}
+}
+
+// schedulerTriggerHandler is the alternate path for /admin/scheduler/:name/run.
+func schedulerTriggerHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if err := svc.Scheduler.RunNow(c.Request.Context(), c.Param("name")); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// ─── SSE ticket store ───────────────────────────────────────────────────────
+//
+// The Vue UI's SSE event stream wants a one-time signed ticket so the
+// EventSource (which can't set Authorization headers) can authenticate.
+// We don't expose the SSE stream itself yet, but we persist short-lived
+// tickets keyed to the user so the upstream consumer keeps working.
+
+type ticket struct {
+	userID  string
+	expires time.Time
+}
+
+var (
+	ticketStore   = map[string]ticket{}
+	ticketStoreMu sync.Mutex
+)
+
+func newTicket(userID string) string {
+	buf := make([]byte, 16)
+	_, _ = rand.Read(buf)
+	t := hex.EncodeToString(buf)
+	ticketStoreMu.Lock()
+	defer ticketStoreMu.Unlock()
+	ticketStore[t] = ticket{userID: userID, expires: time.Now().Add(60 * time.Second)}
+	// GC expired tickets opportunistically.
+	for k, v := range ticketStore {
+		if time.Now().After(v.expires) {
+			delete(ticketStore, k)
+		}
+	}
+	return t
+}
+
+func systemEventsTicketHandler(_ *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		c.JSON(http.StatusOK, gin.H{"ticket": newTicket(toString(uid))})
+	}
+}

internal/handler/system_meta.go

@@ -0,0 +1,66 @@
+// Package handler — system metadata endpoints used by the React shell
+// (footer "powered by", admin status panel, scheduled-task page).
+//
+// These mirror the Vue surface (/api/system/info, /api/system/status,
+// /api/system/scheduler) so the React port can reuse the same calls.
+package handler
+
+import (
+	"net/http"
+	"runtime"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/shirou/gopsutil/v3/cpu"
+	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v3/mem"
+
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// startedAt is captured at first call so /system/status can report uptime
+// without threading state through the container.
+var startedAt = time.Now()
+
+func systemInfoHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"name":      "MediaStationGo",
+			"version":   "0.1.0",
+			"go":        runtime.Version(),
+			"os":        runtime.GOOS,
+			"arch":      runtime.GOARCH,
+			"data_dir":  svc.Cfg.App.DataDir,
+			"cache_dir": svc.Cfg.Cache.CacheDir,
+		})
+	}
+}
+
+func systemStatusHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		out := gin.H{
+			"uptime_seconds": int64(time.Since(startedAt).Seconds()),
+			"goroutines":     runtime.NumGoroutine(),
+		}
+		if usage, err := cpu.Percent(0, false); err == nil && len(usage) > 0 {
+			out["cpu_percent"] = usage[0]
+		}
+		if v, err := mem.VirtualMemory(); err == nil {
+			out["memory_used"] = v.Used
+			out["memory_total"] = v.Total
+		}
+		if d, err := disk.Usage(svc.Cfg.App.DataDir); err == nil {
+			out["disk_used"] = d.Used
+			out["disk_total"] = d.Total
+		}
+		c.JSON(http.StatusOK, out)
+	}
+}
+
+// systemSchedulerHandler is the read-only (non-admin) variant of
+// /admin/scheduler — handy on user-facing dashboards.
+func systemSchedulerHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"jobs": svc.Scheduler.Status()})
+	}
+}

internal/handler/watch_history.go

@@ -0,0 +1,162 @@
+// Package handler — watch history endpoints.
+//
+// The base /history GET / POST routes already exist; these add the three
+// auxiliary surfaces the React WatchHistoryPage needs:
+//
+//   GET  /api/watch-history          paginated list (admin sees every user)
+//   GET  /api/watch-history/stats    aggregate watch time + completion
+//   GET  /api/watch-history/continue resume rail (incomplete only)
+//   DELETE /api/watch-history        clear (?media_item_id= optional)
+//   DELETE /api/watch-history/:id    remove one row
+package handler
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/ShukeBta/MediaStationGo/internal/middleware"
+	"github.com/ShukeBta/MediaStationGo/internal/model"
+	"github.com/ShukeBta/MediaStationGo/internal/service"
+)
+
+// historyListHandler returns the caller's history rows joined with the
+// matching media in a single response.
+func historyListHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "50"))
+		if limit <= 0 || limit > 500 {
+			limit = 50
+		}
+		items, err := svc.Playback.RecentHistory(c.Request.Context(), toString(uid), limit)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.JSON(http.StatusOK, items)
+	}
+}
+
+// historyStatsHandler returns aggregate watch time + completion counts
+// for the caller. Used by the WatchHistoryPage hero card.
+func historyStatsHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		userID := toString(uid)
+
+		var total int64
+		_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ?", userID).Count(&total).Error
+
+		var completed int64
+		_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ? AND completed = ?", userID, true).Count(&completed).Error
+
+		var watchedMs int64
+		_ = svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ?", userID).
+			Select("COALESCE(SUM(position_ms), 0)").
+			Row().Scan(&watchedMs)
+
+		var last *time.Time
+		row := svc.Repo.DB.Model(&model.PlaybackHistory{}).
+			Where("user_id = ?", userID).
+			Select("MAX(watched_at)").Row()
+		var lastT time.Time
+		if err := row.Scan(&lastT); err == nil && !lastT.IsZero() {
+			last = &lastT
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"total":         total,
+			"completed":     completed,
+			"watched_ms":    watchedMs,
+			"watched_hours": float64(watchedMs) / 1000.0 / 3600.0,
+			"last_watched":  last,
+		})
+	}
+}
+
+// historyContinueHandler returns "Continue Watching" rows: incomplete
+// items, most recent first.
+func historyContinueHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
+		if limit <= 0 || limit > 50 {
+			limit = 10
+		}
+		var rows []model.PlaybackHistory
+		if err := svc.Repo.DB.
+			Where("user_id = ? AND completed = ?", toString(uid), false).
+			Order("watched_at desc").
+			Limit(limit).
+			Find(&rows).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		// Hydrate media in one query.
+		ids := make([]string, 0, len(rows))
+		for _, r := range rows {
+			ids = append(ids, r.MediaID)
+		}
+		var media []model.Media
+		if len(ids) > 0 {
+			_ = svc.Repo.DB.Where("id IN ?", ids).Find(&media).Error
+		}
+		mIdx := make(map[string]model.Media, len(media))
+		for _, m := range media {
+			mIdx[m.ID] = m
+		}
+		out := make([]gin.H, 0, len(rows))
+		for _, r := range rows {
+			m, ok := mIdx[r.MediaID]
+			if !ok {
+				continue
+			}
+			out = append(out, gin.H{
+				"history": r,
+				"media":   m,
+			})
+		}
+		c.JSON(http.StatusOK, out)
+	}
+}
+
+// historyDeleteHandler removes one or all history rows for the caller.
+//
+//   DELETE /api/watch-history?media_id=xxx  → delete just that media's row
+//   DELETE /api/watch-history               → clear all rows for the user
+func historyDeleteHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		userID := toString(uid)
+		mediaID := c.Query("media_id")
+
+		q := svc.Repo.DB.Where("user_id = ?", userID)
+		if mediaID != "" {
+			q = q.Where("media_id = ?", mediaID)
+		}
+		if err := q.Delete(&model.PlaybackHistory{}).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}
+
+func historyDeleteOneHandler(svc *service.Container) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uid, _ := c.Get(middleware.CtxUserID)
+		if err := svc.Repo.DB.
+			Where("user_id = ? AND id = ?", toString(uid), c.Param("id")).
+			Delete(&model.PlaybackHistory{}).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		c.Status(http.StatusNoContent)
+	}
+}