hardening

.build_number

@@ -1 +0,0 @@
-271261524

README.md

@@ -64,10 +64,10 @@ QBIT_URL="http://localhost:8080"
 QBIT_USERNAME="..."
 QBIT_PASSWORD="..."
 SQLITE_PATH="data/magent.db"
-JWT_SECRET="change-me"
+JWT_SECRET="replace-with-a-long-random-secret"
 JWT_EXP_MINUTES="720"
-ADMIN_USERNAME="admin"
+ADMIN_USERNAME="set-a-real-admin-username"
-ADMIN_PASSWORD="adminadmin"
+ADMIN_PASSWORD="set-a-long-unique-admin-password"
 ```
 
 ## Screenshots
@@ -112,10 +112,10 @@ $env:QBIT_URL="http://localhost:8080"
 $env:QBIT_USERNAME="..."
 $env:QBIT_PASSWORD="..."
 $env:SQLITE_PATH="data/magent.db"
-$env:JWT_SECRET="change-me"
+$env:JWT_SECRET="replace-with-a-long-random-secret"
 $env:JWT_EXP_MINUTES="720"
-$env:ADMIN_USERNAME="admin"
+$env:ADMIN_USERNAME="set-a-real-admin-username"
-$env:ADMIN_PASSWORD="adminadmin"
+$env:ADMIN_PASSWORD="set-a-long-unique-admin-password"
 ```
 
 ### Frontend (Next.js)

backend/Dockerfile

@@ -2,11 +2,8 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
-ARG BUILD_NUMBER=dev
-
 ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
+    PYTHONUNBUFFERED=1
-    SITE_BUILD_NUMBER=${BUILD_NUMBER}
 
 COPY backend/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

backend/app/ai/triage.py

@@ -26,7 +26,7 @@ def triage_snapshot(snapshot: Snapshot) -> TriageResult:
         recommendations.append(
             TriageRecommendation(
                 action_id="readd_to_arr",
-                title="Push to Sonarr/Radarr",
+                title="Add it to the library queue",
                 reason="Sonarr/Radarr has not created the entry for this request.",
                 risk="medium",
             )

backend/app/auth.py

@@ -1,28 +1,15 @@
 from typing import Dict, Any
 
-from fastapi import Depends, HTTPException, status, Request
+from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 
-from .db import get_user_by_username, upsert_user_activity
+from .db import get_user_by_username
 from .security import safe_decode_token, TokenError
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
 
-def _extract_client_ip(request: Request) -> str:
-    forwarded = request.headers.get("x-forwarded-for")
-    if forwarded:
-        parts = [part.strip() for part in forwarded.split(",") if part.strip()]
-        if parts:
-            return parts[0]
-    real_ip = request.headers.get("x-real-ip")
-    if real_ip:
-        return real_ip.strip()
-    if request.client and request.client.host:
-        return request.client.host
-    return "unknown"
 
-
+def get_current_user(token: str = Depends(oauth2_scheme)) -> Dict[str, Any]:
-def get_current_user(token: str = Depends(oauth2_scheme), request: Request = None) -> Dict[str, Any]:
     try:
         payload = safe_decode_token(token)
     except TokenError as exc:
@@ -38,11 +25,6 @@ def get_current_user(token: str = Depends(oauth2_scheme), request: Request = Non
     if user.get("is_blocked"):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
 
-    if request is not None:
-        ip = _extract_client_ip(request)
-        user_agent = request.headers.get("user-agent", "unknown")
-        upsert_user_activity(user["username"], ip, user_agent)
-
     return {
         "username": user["username"],
         "role": user["role"],

backend/app/clients/jellyfin.py

@@ -58,13 +58,3 @@ class JellyfinClient(ApiClient):
             response = await client.get(url, headers=headers)
             response.raise_for_status()
             return response.json()
-
-    async def refresh_library(self, recursive: bool = True) -> None:
-        if not self.base_url or not self.api_key:
-            return None
-        url = f"{self.base_url}/Library/Refresh"
-        headers = {"X-Emby-Token": self.api_key}
-        params = {"Recursive": "true" if recursive else "false"}
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.post(url, headers=headers, params=params)
-            response.raise_for_status()

backend/app/clients/qbittorrent.py

@@ -1,6 +1,5 @@
 from typing import Any, Dict, Optional
 import httpx
-import logging
 from .base import ApiClient
 
 
@@ -9,7 +8,6 @@ class QBittorrentClient(ApiClient):
         super().__init__(base_url, None)
         self.username = username
         self.password = password
-        self.logger = logging.getLogger(__name__)
 
     def configured(self) -> bool:
         return bool(self.base_url and self.username and self.password)
@@ -74,14 +72,6 @@ class QBittorrentClient(ApiClient):
             raise
 
     async def add_torrent_url(self, url: str, category: Optional[str] = None) -> None:
-        url_host = None
-        if isinstance(url, str) and "://" in url:
-            url_host = url.split("://", 1)[-1].split("/", 1)[0]
-        self.logger.warning(
-            "qBittorrent add_torrent_url invoked: category=%s host=%s",
-            category,
-            url_host or "unknown",
-        )
         data: Dict[str, Any] = {"urls": url}
         if category:
             data["category"] = category

backend/app/clients/radarr.py

@@ -21,9 +21,6 @@ class RadarrClient(ApiClient):
     async def get_queue(self, movie_id: int) -> Optional[Dict[str, Any]]:
         return await self.get("/api/v3/queue", params={"movieId": movie_id})
 
-    async def get_indexers(self) -> Optional[Dict[str, Any]]:
-        return await self.get("/api/v3/indexer")
-
     async def search(self, movie_id: int) -> Optional[Dict[str, Any]]:
         return await self.post("/api/v3/command", payload={"name": "MoviesSearch", "movieIds": [movie_id]})
 
@@ -46,12 +43,3 @@ class RadarrClient(ApiClient):
 
     async def grab_release(self, guid: str, indexer_id: int) -> Optional[Dict[str, Any]]:
         return await self.post("/api/v3/release", payload={"guid": guid, "indexerId": indexer_id})
-
-    async def push_release(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        return await self.post("/api/v3/release/push", payload=payload)
-
-    async def download_release(self, guid: str, indexer_id: int) -> Optional[Dict[str, Any]]:
-        return await self.post(
-            "/api/v3/command",
-            payload={"name": "DownloadRelease", "guid": guid, "indexerId": indexer_id},
-        )

backend/app/clients/sonarr.py

@@ -18,9 +18,6 @@ class SonarrClient(ApiClient):
     async def get_queue(self, series_id: int) -> Optional[Dict[str, Any]]:
         return await self.get("/api/v3/queue", params={"seriesId": series_id})
 
-    async def get_indexers(self) -> Optional[Dict[str, Any]]:
-        return await self.get("/api/v3/indexer")
-
     async def get_episodes(self, series_id: int) -> Optional[Dict[str, Any]]:
         return await self.get("/api/v3/episode", params={"seriesId": series_id})
 
@@ -53,12 +50,3 @@ class SonarrClient(ApiClient):
 
     async def grab_release(self, guid: str, indexer_id: int) -> Optional[Dict[str, Any]]:
         return await self.post("/api/v3/release", payload={"guid": guid, "indexerId": indexer_id})
-
-    async def push_release(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        return await self.post("/api/v3/release/push", payload=payload)
-
-    async def download_release(self, guid: str, indexer_id: int) -> Optional[Dict[str, Any]]:
-        return await self.post(
-            "/api/v3/command",
-            payload={"name": "DownloadRelease", "guid": guid, "indexerId": indexer_id},
-        )

backend/app/config.py

@@ -8,10 +8,10 @@ class Settings(BaseSettings):
     app_name: str = "Magent"
     cors_allow_origin: str = "http://localhost:3000"
     sqlite_path: str = Field(default="data/magent.db", validation_alias=AliasChoices("SQLITE_PATH"))
-    jwt_secret: str = Field(default="change-me", validation_alias=AliasChoices("JWT_SECRET"))
+    jwt_secret: Optional[str] = Field(default=None, validation_alias=AliasChoices("JWT_SECRET"))
     jwt_exp_minutes: int = Field(default=720, validation_alias=AliasChoices("JWT_EXP_MINUTES"))
-    admin_username: str = Field(default="admin", validation_alias=AliasChoices("ADMIN_USERNAME"))
+    admin_username: Optional[str] = Field(default=None, validation_alias=AliasChoices("ADMIN_USERNAME"))
-    admin_password: str = Field(default="adminadmin", validation_alias=AliasChoices("ADMIN_PASSWORD"))
+    admin_password: Optional[str] = Field(default=None, validation_alias=AliasChoices("ADMIN_PASSWORD"))
     log_level: str = Field(default="INFO", validation_alias=AliasChoices("LOG_LEVEL"))
     log_file: str = Field(default="data/magent.log", validation_alias=AliasChoices("LOG_FILE"))
     requests_sync_ttl_minutes: int = Field(
@@ -38,21 +38,6 @@ class Settings(BaseSettings):
     artwork_cache_mode: str = Field(
         default="remote", validation_alias=AliasChoices("ARTWORK_CACHE_MODE")
     )
-    site_build_number: Optional[str] = Field(
-        default=None, validation_alias=AliasChoices("SITE_BUILD_NUMBER")
-    )
-    site_banner_enabled: bool = Field(
-        default=False, validation_alias=AliasChoices("SITE_BANNER_ENABLED")
-    )
-    site_banner_message: Optional[str] = Field(
-        default=None, validation_alias=AliasChoices("SITE_BANNER_MESSAGE")
-    )
-    site_banner_tone: str = Field(
-        default="info", validation_alias=AliasChoices("SITE_BANNER_TONE")
-    )
-    site_changelog: Optional[str] = Field(
-        default=None, validation_alias=AliasChoices("SITE_CHANGELOG")
-    )
 
     jellyseerr_base_url: Optional[str] = Field(
         default=None, validation_alias=AliasChoices("JELLYSEERR_URL", "JELLYSEERR_BASE_URL")
@@ -85,10 +70,6 @@ class Settings(BaseSettings):
     sonarr_root_folder: Optional[str] = Field(
         default=None, validation_alias=AliasChoices("SONARR_ROOT_FOLDER")
     )
-    sonarr_qbittorrent_category: Optional[str] = Field(
-        default="sonarr",
-        validation_alias=AliasChoices("SONARR_QBITTORRENT_CATEGORY"),
-    )
 
     radarr_base_url: Optional[str] = Field(
         default=None, validation_alias=AliasChoices("RADARR_URL", "RADARR_BASE_URL")
@@ -102,10 +83,6 @@ class Settings(BaseSettings):
     radarr_root_folder: Optional[str] = Field(
         default=None, validation_alias=AliasChoices("RADARR_ROOT_FOLDER")
     )
-    radarr_qbittorrent_category: Optional[str] = Field(
-        default="radarr",
-        validation_alias=AliasChoices("RADARR_QBITTORRENT_CATEGORY"),
-    )
 
     prowlarr_base_url: Optional[str] = Field(
         default=None, validation_alias=AliasChoices("PROWLARR_URL", "PROWLARR_BASE_URL")
@@ -125,7 +102,7 @@ class Settings(BaseSettings):
     )
 
     discord_webhook_url: Optional[str] = Field(
-        default="https://discord.com/api/webhooks/1464141924775629033/O_rvCAmIKowR04tyAN54IuMPcQFEiT-ustU3udDaMTlF62PmoI6w4-52H3ZQcjgHQOgt",
+        default=None,
         validation_alias=AliasChoices("DISCORD_WEBHOOK_URL"),
     )
 

backend/app/db.py

@@ -24,92 +24,6 @@ def _connect() -> sqlite3.Connection:
     return sqlite3.connect(_db_path())
 
 
-def _normalize_title_value(title: Optional[str]) -> Optional[str]:
-    if not isinstance(title, str):
-        return None
-    trimmed = title.strip()
-    return trimmed if trimmed else None
-
-
-def _normalize_year_value(year: Optional[Any]) -> Optional[int]:
-    if isinstance(year, int):
-        return year
-    if isinstance(year, str):
-        trimmed = year.strip()
-        if trimmed.isdigit():
-            return int(trimmed)
-    return None
-
-
-def _is_placeholder_title(title: Optional[str], request_id: Optional[int]) -> bool:
-    if not isinstance(title, str):
-        return True
-    normalized = title.strip().lower()
-    if not normalized:
-        return True
-    if normalized == "untitled":
-        return True
-    if request_id and normalized == f"request {request_id}":
-        return True
-    return False
-
-
-def _extract_title_year_from_payload(payload_json: Optional[str]) -> tuple[Optional[str], Optional[int]]:
-    if not payload_json:
-        return None, None
-    try:
-        payload = json.loads(payload_json)
-    except json.JSONDecodeError:
-        return None, None
-    if not isinstance(payload, dict):
-        return None, None
-    media = payload.get("media") or {}
-    title = None
-    year = None
-    if isinstance(media, dict):
-        title = media.get("title") or media.get("name")
-        year = media.get("year")
-    if not title:
-        title = payload.get("title") or payload.get("name")
-    if year is None:
-        year = payload.get("year")
-    return _normalize_title_value(title), _normalize_year_value(year)
-
-
-def _extract_tmdb_from_payload(payload_json: Optional[str]) -> tuple[Optional[int], Optional[str]]:
-    if not payload_json:
-        return None, None
-    try:
-        payload = json.loads(payload_json)
-    except (TypeError, json.JSONDecodeError):
-        return None, None
-    if not isinstance(payload, dict):
-        return None, None
-    media = payload.get("media") or {}
-    if not isinstance(media, dict):
-        media = {}
-    tmdb_id = (
-        media.get("tmdbId")
-        or payload.get("tmdbId")
-        or payload.get("tmdb_id")
-        or media.get("externalServiceId")
-        or payload.get("externalServiceId")
-    )
-    media_type = (
-        media.get("mediaType")
-        or payload.get("mediaType")
-        or payload.get("media_type")
-        or payload.get("type")
-    )
-    try:
-        tmdb_id = int(tmdb_id) if tmdb_id is not None else None
-    except (TypeError, ValueError):
-        tmdb_id = None
-    if isinstance(media_type, str):
-        media_type = media_type.strip().lower() or None
-    return tmdb_id, media_type
-
-
 def init_db() -> None:
     with _connect() as conn:
         conn.execute(
@@ -147,9 +61,7 @@ def init_db() -> None:
                 auth_provider TEXT NOT NULL DEFAULT 'local',
                 created_at TEXT NOT NULL,
                 last_login_at TEXT,
-                is_blocked INTEGER NOT NULL DEFAULT 0,
+                is_blocked INTEGER NOT NULL DEFAULT 0
-                jellyfin_password_hash TEXT,
-                last_jellyfin_auth_at TEXT
             )
             """
         )
@@ -179,21 +91,6 @@ def init_db() -> None:
             )
             """
         )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS artwork_cache_status (
-                request_id INTEGER PRIMARY KEY,
-                tmdb_id INTEGER,
-                media_type TEXT,
-                poster_path TEXT,
-                backdrop_path TEXT,
-                has_tmdb INTEGER NOT NULL DEFAULT 0,
-                poster_cached INTEGER NOT NULL DEFAULT 0,
-                backdrop_cached INTEGER NOT NULL DEFAULT 0,
-                updated_at TEXT NOT NULL
-            )
-            """
-        )
         conn.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_requests_cache_created_at
@@ -206,38 +103,6 @@ def init_db() -> None:
             ON requests_cache (requested_by_norm)
             """
         )
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_artwork_cache_status_updated_at
-            ON artwork_cache_status (updated_at)
-            """
-        )
-        conn.execute(
-            """
-            CREATE TABLE IF NOT EXISTS user_activity (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                username TEXT NOT NULL,
-                ip TEXT NOT NULL,
-                user_agent TEXT NOT NULL,
-                first_seen_at TEXT NOT NULL,
-                last_seen_at TEXT NOT NULL,
-                hit_count INTEGER NOT NULL DEFAULT 1,
-                UNIQUE(username, ip, user_agent)
-            )
-            """
-        )
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_user_activity_username
-            ON user_activity (username)
-            """
-        )
-        conn.execute(
-            """
-            CREATE INDEX IF NOT EXISTS idx_user_activity_last_seen
-            ON user_activity (last_seen_at)
-            """
-        )
         try:
             conn.execute("ALTER TABLE users ADD COLUMN last_login_at TEXT")
         except sqlite3.OperationalError:
@@ -250,14 +115,6 @@ def init_db() -> None:
             conn.execute("ALTER TABLE users ADD COLUMN auth_provider TEXT NOT NULL DEFAULT 'local'")
         except sqlite3.OperationalError:
             pass
-        try:
-            conn.execute("ALTER TABLE users ADD COLUMN jellyfin_password_hash TEXT")
-        except sqlite3.OperationalError:
-            pass
-        try:
-            conn.execute("ALTER TABLE users ADD COLUMN last_jellyfin_auth_at TEXT")
-        except sqlite3.OperationalError:
-            pass
     _backfill_auth_providers()
     ensure_admin_user()
 
@@ -394,8 +251,7 @@ def get_user_by_username(username: str) -> Optional[Dict[str, Any]]:
     with _connect() as conn:
         row = conn.execute(
             """
-            SELECT id, username, password_hash, role, auth_provider, created_at, last_login_at,
+            SELECT id, username, password_hash, role, auth_provider, created_at, last_login_at, is_blocked
-                   is_blocked, jellyfin_password_hash, last_jellyfin_auth_at
             FROM users
             WHERE username = ?
             """,
@@ -412,8 +268,6 @@ def get_user_by_username(username: str) -> Optional[Dict[str, Any]]:
         "created_at": row[5],
         "last_login_at": row[6],
         "is_blocked": bool(row[7]),
-        "jellyfin_password_hash": row[8],
-        "last_jellyfin_auth_at": row[9],
     }
 
 
@@ -477,6 +331,8 @@ def verify_user_password(username: str, password: str) -> Optional[Dict[str, Any
     user = get_user_by_username(username)
     if not user:
         return None
+    if user.get("auth_provider") != "local":
+        return None
     if not verify_password(password, user["password_hash"]):
         return None
     return user
@@ -493,22 +349,6 @@ def set_user_password(username: str, password: str) -> None:
         )
 
 
-def set_jellyfin_auth_cache(username: str, password: str) -> None:
-    if not username or not password:
-        return
-    password_hash = hash_password(password)
-    timestamp = datetime.now(timezone.utc).isoformat()
-    with _connect() as conn:
-        conn.execute(
-            """
-            UPDATE users
-            SET jellyfin_password_hash = ?, last_jellyfin_auth_at = ?
-            WHERE username = ?
-            """,
-            (password_hash, timestamp, username),
-        )
-
-
 def _backfill_auth_providers() -> None:
     with _connect() as conn:
         rows = conn.execute(
@@ -539,164 +379,6 @@ def _backfill_auth_providers() -> None:
         )
 
 
-def upsert_user_activity(username: str, ip: str, user_agent: str) -> None:
-    if not username:
-        return
-    ip_value = ip.strip() if isinstance(ip, str) and ip.strip() else "unknown"
-    agent_value = (
-        user_agent.strip() if isinstance(user_agent, str) and user_agent.strip() else "unknown"
-    )
-    timestamp = datetime.now(timezone.utc).isoformat()
-    with _connect() as conn:
-        conn.execute(
-            """
-            INSERT INTO user_activity (username, ip, user_agent, first_seen_at, last_seen_at, hit_count)
-            VALUES (?, ?, ?, ?, ?, 1)
-            ON CONFLICT(username, ip, user_agent)
-            DO UPDATE SET last_seen_at = excluded.last_seen_at, hit_count = hit_count + 1
-            """,
-            (username, ip_value, agent_value, timestamp, timestamp),
-        )
-
-
-def get_user_activity(username: str, limit: int = 5) -> list[Dict[str, Any]]:
-    limit = max(1, min(limit, 20))
-    with _connect() as conn:
-        rows = conn.execute(
-            """
-            SELECT ip, user_agent, first_seen_at, last_seen_at, hit_count
-            FROM user_activity
-            WHERE username = ?
-            ORDER BY last_seen_at DESC
-            LIMIT ?
-            """,
-            (username, limit),
-        ).fetchall()
-    results: list[Dict[str, Any]] = []
-    for row in rows:
-        results.append(
-            {
-                "ip": row[0],
-                "user_agent": row[1],
-                "first_seen_at": row[2],
-                "last_seen_at": row[3],
-                "hit_count": row[4],
-            }
-        )
-    return results
-
-
-def get_user_activity_summary(username: str) -> Dict[str, Any]:
-    with _connect() as conn:
-        last_row = conn.execute(
-            """
-            SELECT ip, user_agent, last_seen_at
-            FROM user_activity
-            WHERE username = ?
-            ORDER BY last_seen_at DESC
-            LIMIT 1
-            """,
-            (username,),
-        ).fetchone()
-        count_row = conn.execute(
-            """
-            SELECT COUNT(*)
-            FROM user_activity
-            WHERE username = ?
-            """,
-            (username,),
-        ).fetchone()
-    return {
-        "last_ip": last_row[0] if last_row else None,
-        "last_user_agent": last_row[1] if last_row else None,
-        "last_seen_at": last_row[2] if last_row else None,
-        "device_count": int(count_row[0] or 0) if count_row else 0,
-    }
-
-
-def get_user_request_stats(username_norm: str) -> Dict[str, Any]:
-    if not username_norm:
-        return {
-            "total": 0,
-            "ready": 0,
-            "pending": 0,
-            "approved": 0,
-            "working": 0,
-            "partial": 0,
-            "declined": 0,
-            "in_progress": 0,
-            "last_request_at": None,
-        }
-    with _connect() as conn:
-        total_row = conn.execute(
-            """
-            SELECT COUNT(*)
-            FROM requests_cache
-            WHERE requested_by_norm = ?
-            """,
-            (username_norm,),
-        ).fetchone()
-        status_rows = conn.execute(
-            """
-            SELECT status, COUNT(*)
-            FROM requests_cache
-            WHERE requested_by_norm = ?
-            GROUP BY status
-            """,
-            (username_norm,),
-        ).fetchall()
-        last_row = conn.execute(
-            """
-            SELECT MAX(created_at)
-            FROM requests_cache
-            WHERE requested_by_norm = ?
-            """,
-            (username_norm,),
-        ).fetchone()
-    counts = {int(row[0]): int(row[1]) for row in status_rows if row[0] is not None}
-    pending = counts.get(1, 0)
-    approved = counts.get(2, 0)
-    declined = counts.get(3, 0)
-    ready = counts.get(4, 0)
-    working = counts.get(5, 0)
-    partial = counts.get(6, 0)
-    in_progress = approved + working + partial
-    return {
-        "total": int(total_row[0] or 0) if total_row else 0,
-        "ready": ready,
-        "pending": pending,
-        "approved": approved,
-        "working": working,
-        "partial": partial,
-        "declined": declined,
-        "in_progress": in_progress,
-        "last_request_at": last_row[0] if last_row else None,
-    }
-
-
-def get_global_request_leader() -> Optional[Dict[str, Any]]:
-    with _connect() as conn:
-        row = conn.execute(
-            """
-            SELECT requested_by_norm, MAX(requested_by) as display_name, COUNT(*) as total
-            FROM requests_cache
-            WHERE requested_by_norm IS NOT NULL AND requested_by_norm != ''
-            GROUP BY requested_by_norm
-            ORDER BY total DESC
-            LIMIT 1
-            """
-        ).fetchone()
-    if not row:
-        return None
-    return {"username": row[1] or row[0], "total": int(row[2] or 0)}
-
-
-def get_global_request_total() -> int:
-    with _connect() as conn:
-        row = conn.execute("SELECT COUNT(*) FROM requests_cache").fetchone()
-    return int(row[0] or 0)
-
-
 def upsert_request_cache(
     request_id: int,
     media_id: Optional[int],
@@ -710,34 +392,7 @@ def upsert_request_cache(
     updated_at: Optional[str],
     payload_json: str,
 ) -> None:
-    normalized_title = _normalize_title_value(title)
-    normalized_year = _normalize_year_value(year)
-    derived_title = None
-    derived_year = None
-    if not normalized_title or normalized_year is None:
-        derived_title, derived_year = _extract_title_year_from_payload(payload_json)
-    if _is_placeholder_title(normalized_title, request_id):
-        normalized_title = None
-    if derived_title and not normalized_title:
-        normalized_title = derived_title
-    if normalized_year is None and derived_year is not None:
-        normalized_year = derived_year
     with _connect() as conn:
-        existing_title = None
-        existing_year = None
-        if normalized_title is None or normalized_year is None:
-            row = conn.execute(
-                "SELECT title, year FROM requests_cache WHERE request_id = ?",
-                (request_id,),
-            ).fetchone()
-            if row:
-                existing_title, existing_year = row[0], row[1]
-                if _is_placeholder_title(existing_title, request_id):
-                    existing_title = None
-        if normalized_title is None and existing_title:
-            normalized_title = existing_title
-        if normalized_year is None and existing_year is not None:
-            normalized_year = existing_year
         conn.execute(
             """
             INSERT INTO requests_cache (
@@ -771,8 +426,8 @@ def upsert_request_cache(
                 media_id,
                 media_type,
                 status,
-                normalized_title,
+                title,
-                normalized_year,
+                year,
                 requested_by,
                 requested_by_norm,
                 created_at,
@@ -875,11 +530,22 @@ def get_cached_requests(
         title = row[4]
         year = row[5]
         if (not title or not year) and row[8]:
-            derived_title, derived_year = _extract_title_year_from_payload(row[8])
+            try:
-            if not title:
+                payload = json.loads(row[8])
-                title = derived_title
+                if isinstance(payload, dict):
-            if not year:
+                    media = payload.get("media") or {}
-                year = derived_year
+                    if not title:
+                        title = (
+                            (media.get("title") if isinstance(media, dict) else None)
+                            or (media.get("name") if isinstance(media, dict) else None)
+                            or payload.get("title")
+                            or payload.get("name")
+                        )
+                    if not year:
+                        year = media.get("year") if isinstance(media, dict) else None
+                        year = year or payload.get("year")
+            except json.JSONDecodeError:
+                pass
         results.append(
             {
                 "request_id": row[0],
@@ -911,8 +577,18 @@ def get_request_cache_overview(limit: int = 50) -> list[Dict[str, Any]]:
     for row in rows:
         title = row[4]
         if not title and row[9]:
-            derived_title, _ = _extract_title_year_from_payload(row[9])
+            try:
-            title = derived_title or row[4]
+                payload = json.loads(row[9])
+                if isinstance(payload, dict):
+                    media = payload.get("media") or {}
+                    title = (
+                        (media.get("title") if isinstance(media, dict) else None)
+                        or (media.get("name") if isinstance(media, dict) else None)
+                        or payload.get("title")
+                        or payload.get("name")
+                    )
+            except json.JSONDecodeError:
+                title = row[4]
         results.append(
             {
                 "request_id": row[0],
@@ -929,200 +605,12 @@ def get_request_cache_overview(limit: int = 50) -> list[Dict[str, Any]]:
     return results
 
 
-def get_request_cache_missing_titles(limit: int = 200) -> list[Dict[str, Any]]:
-    limit = max(1, min(limit, 500))
-    with _connect() as conn:
-        rows = conn.execute(
-            """
-            SELECT request_id, payload_json
-            FROM requests_cache
-            WHERE title IS NULL OR TRIM(title) = '' OR LOWER(title) = 'untitled'
-            ORDER BY updated_at DESC, request_id DESC
-            LIMIT ?
-            """,
-            (limit,),
-        ).fetchall()
-    results: list[Dict[str, Any]] = []
-    for row in rows:
-        payload_json = row[1]
-        tmdb_id, media_type = _extract_tmdb_from_payload(payload_json)
-        results.append(
-            {
-                "request_id": row[0],
-                "payload_json": payload_json,
-                "tmdb_id": tmdb_id,
-                "media_type": media_type,
-            }
-        )
-    return results
-
-
 def get_request_cache_count() -> int:
     with _connect() as conn:
         row = conn.execute("SELECT COUNT(*) FROM requests_cache").fetchone()
     return int(row[0] or 0)
 
 
-def upsert_artwork_cache_status(
-    request_id: int,
-    tmdb_id: Optional[int],
-    media_type: Optional[str],
-    poster_path: Optional[str],
-    backdrop_path: Optional[str],
-    has_tmdb: bool,
-    poster_cached: bool,
-    backdrop_cached: bool,
-) -> None:
-    updated_at = datetime.now(timezone.utc).isoformat()
-    with _connect() as conn:
-        conn.execute(
-            """
-            INSERT INTO artwork_cache_status (
-                request_id,
-                tmdb_id,
-                media_type,
-                poster_path,
-                backdrop_path,
-                has_tmdb,
-                poster_cached,
-                backdrop_cached,
-                updated_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(request_id) DO UPDATE SET
-                tmdb_id = excluded.tmdb_id,
-                media_type = excluded.media_type,
-                poster_path = excluded.poster_path,
-                backdrop_path = excluded.backdrop_path,
-                has_tmdb = excluded.has_tmdb,
-                poster_cached = excluded.poster_cached,
-                backdrop_cached = excluded.backdrop_cached,
-                updated_at = excluded.updated_at
-            """,
-            (
-                request_id,
-                tmdb_id,
-                media_type,
-                poster_path,
-                backdrop_path,
-                1 if has_tmdb else 0,
-                1 if poster_cached else 0,
-                1 if backdrop_cached else 0,
-                updated_at,
-            ),
-        )
-
-
-def get_artwork_cache_status_count() -> int:
-    with _connect() as conn:
-        row = conn.execute("SELECT COUNT(*) FROM artwork_cache_status").fetchone()
-    return int(row[0] or 0)
-
-
-def get_artwork_cache_missing_count() -> int:
-    with _connect() as conn:
-        row = conn.execute(
-            """
-            SELECT COUNT(*)
-            FROM artwork_cache_status
-            WHERE (
-                (poster_path IS NULL AND has_tmdb = 1)
-                OR (poster_path IS NOT NULL AND poster_cached = 0)
-                OR (backdrop_path IS NULL AND has_tmdb = 1)
-                OR (backdrop_path IS NOT NULL AND backdrop_cached = 0)
-            )
-            """
-        ).fetchone()
-    return int(row[0] or 0)
-
-
-def update_artwork_cache_stats(
-    cache_bytes: Optional[int] = None,
-    cache_files: Optional[int] = None,
-    missing_count: Optional[int] = None,
-    total_requests: Optional[int] = None,
-) -> None:
-    updated_at = datetime.now(timezone.utc).isoformat()
-    if cache_bytes is not None:
-        set_setting("artwork_cache_bytes", str(int(cache_bytes)))
-    if cache_files is not None:
-        set_setting("artwork_cache_files", str(int(cache_files)))
-    if missing_count is not None:
-        set_setting("artwork_cache_missing", str(int(missing_count)))
-    if total_requests is not None:
-        set_setting("artwork_cache_total_requests", str(int(total_requests)))
-    set_setting("artwork_cache_updated_at", updated_at)
-
-
-def get_artwork_cache_stats() -> Dict[str, Any]:
-    def _get_int(key: str) -> int:
-        value = get_setting(key)
-        if value is None:
-            return 0
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            return 0
-
-    return {
-        "cache_bytes": _get_int("artwork_cache_bytes"),
-        "cache_files": _get_int("artwork_cache_files"),
-        "missing_artwork": _get_int("artwork_cache_missing"),
-        "total_requests": _get_int("artwork_cache_total_requests"),
-        "updated_at": get_setting("artwork_cache_updated_at"),
-    }
-
-
-def get_request_cache_stats() -> Dict[str, Any]:
-    return get_artwork_cache_stats()
-
-
-def update_request_cache_title(
-    request_id: int, title: str, year: Optional[int] = None
-) -> None:
-    normalized_title = _normalize_title_value(title)
-    normalized_year = _normalize_year_value(year)
-    if not normalized_title:
-        return
-    with _connect() as conn:
-        conn.execute(
-            """
-            UPDATE requests_cache
-            SET title = ?, year = COALESCE(?, year)
-            WHERE request_id = ?
-            """,
-            (normalized_title, normalized_year, request_id),
-        )
-
-
-def repair_request_cache_titles() -> int:
-    updated = 0
-    with _connect() as conn:
-        rows = conn.execute(
-            """
-            SELECT request_id, title, year, payload_json
-            FROM requests_cache
-            """
-        ).fetchall()
-        for row in rows:
-            request_id, title, year, payload_json = row
-            if not _is_placeholder_title(title, request_id):
-                continue
-            derived_title, derived_year = _extract_title_year_from_payload(payload_json)
-            if not derived_title:
-                continue
-            conn.execute(
-                """
-                UPDATE requests_cache
-                SET title = ?, year = COALESCE(?, year)
-                WHERE request_id = ?
-                """,
-                (derived_title, derived_year, request_id),
-            )
-            updated += 1
-    return updated
-
-
 def prune_duplicate_requests_cache() -> int:
     with _connect() as conn:
         cursor = conn.execute(
@@ -1165,39 +653,6 @@ def get_request_cache_payloads(limit: int = 200, offset: int = 0) -> list[Dict[s
     return results
 
 
-def get_request_cache_payloads_missing(limit: int = 200, offset: int = 0) -> list[Dict[str, Any]]:
-    limit = max(1, min(limit, 1000))
-    offset = max(0, offset)
-    with _connect() as conn:
-        rows = conn.execute(
-            """
-            SELECT rc.request_id, rc.payload_json
-            FROM requests_cache rc
-            JOIN artwork_cache_status acs
-              ON rc.request_id = acs.request_id
-            WHERE (
-                (acs.poster_path IS NULL AND acs.has_tmdb = 1)
-                OR (acs.poster_path IS NOT NULL AND acs.poster_cached = 0)
-                OR (acs.backdrop_path IS NULL AND acs.has_tmdb = 1)
-                OR (acs.backdrop_path IS NOT NULL AND acs.backdrop_cached = 0)
-            )
-            ORDER BY rc.request_id ASC
-            LIMIT ? OFFSET ?
-            """,
-            (limit, offset),
-        ).fetchall()
-    results: list[Dict[str, Any]] = []
-    for row in rows:
-        payload = None
-        if row[1]:
-            try:
-                payload = json.loads(row[1])
-            except json.JSONDecodeError:
-                payload = None
-        results.append({"request_id": row[0], "payload": payload})
-    return results
-
-
 def get_cached_requests_since(since_iso: str) -> list[Dict[str, Any]]:
     with _connect() as conn:
         rows = conn.execute(

backend/app/main.py

@@ -1,10 +1,11 @@
 import asyncio
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from .config import settings
-from .db import init_db, set_setting
+from .db import init_db
 from .routers.requests import (
     router as requests_router,
     startup_warmup_requests_cache,
@@ -18,12 +19,52 @@ from .routers.images import router as images_router
 from .routers.branding import router as branding_router
 from .routers.status import router as status_router
 from .routers.feedback import router as feedback_router
-from .routers.site import router as site_router
 from .services.jellyfin_sync import run_daily_jellyfin_sync
 from .logging_config import configure_logging
 from .runtime import get_runtime_settings
 
-app = FastAPI(title=settings.app_name)
+
+def validate_security_settings() -> None:
+    issues = []
+    jwt_secret = (settings.jwt_secret or "").strip()
+    admin_username = (settings.admin_username or "").strip()
+    admin_password = (settings.admin_password or "").strip()
+    if not jwt_secret:
+        issues.append("JWT_SECRET is required")
+    if not admin_username:
+        issues.append("ADMIN_USERNAME is required")
+    if not admin_password:
+        issues.append("ADMIN_PASSWORD is required")
+    if jwt_secret == "change-me":
+        issues.append("JWT_SECRET must not use the default placeholder")
+    if admin_password == "adminadmin":
+        issues.append("ADMIN_PASSWORD must not use the default placeholder")
+    if issues:
+        raise RuntimeError("Unsafe Magent security configuration: " + "; ".join(issues))
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    validate_security_settings()
+    init_db()
+    runtime = get_runtime_settings()
+    configure_logging(runtime.log_level, runtime.log_file)
+    background_tasks = [
+        asyncio.create_task(run_daily_jellyfin_sync(), name="daily-jellyfin-sync"),
+        asyncio.create_task(startup_warmup_requests_cache(), name="startup-warmup-requests-cache"),
+        asyncio.create_task(run_requests_delta_loop(), name="requests-delta-loop"),
+        asyncio.create_task(run_daily_requests_full_sync(), name="daily-requests-full-sync"),
+        asyncio.create_task(run_daily_db_cleanup(), name="daily-db-cleanup"),
+    ]
+    try:
+        yield
+    finally:
+        for task in background_tasks:
+            task.cancel()
+        await asyncio.gather(*background_tasks, return_exceptions=True)
+
+
+app = FastAPI(title=settings.app_name, lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
@@ -38,19 +79,6 @@ app.add_middleware(
 async def health() -> dict:
     return {"status": "ok"}
 
-@app.on_event("startup")
-async def startup() -> None:
-    init_db()
-    if settings.site_build_number and settings.site_build_number.strip():
-        set_setting("site_build_number", settings.site_build_number.strip())
-    runtime = get_runtime_settings()
-    configure_logging(runtime.log_level, runtime.log_file)
-    asyncio.create_task(run_daily_jellyfin_sync())
-    asyncio.create_task(startup_warmup_requests_cache())
-    asyncio.create_task(run_requests_delta_loop())
-    asyncio.create_task(run_daily_requests_full_sync())
-    asyncio.create_task(run_daily_db_cleanup())
-
 
 app.include_router(requests_router)
 app.include_router(auth_router)
@@ -59,4 +87,3 @@ app.include_router(images_router)
 app.include_router(branding_router)
 app.include_router(status_router)
 app.include_router(feedback_router)
-app.include_router(site_router)

backend/app/routers/admin.py

@@ -9,8 +9,6 @@ from ..db import (
     delete_setting,
     get_all_users,
     get_request_cache_overview,
-    get_request_cache_missing_titles,
-    get_request_cache_stats,
     get_settings_overrides,
     get_user_by_username,
     set_setting,
@@ -22,8 +20,6 @@ from ..db import (
     clear_requests_cache,
     clear_history,
     cleanup_history,
-    update_request_cache_title,
-    repair_request_cache_titles,
 )
 from ..runtime import get_runtime_settings
 from ..clients.sonarr import SonarrClient
@@ -60,12 +56,10 @@ SETTING_KEYS: List[str] = [
     "sonarr_api_key",
     "sonarr_quality_profile_id",
     "sonarr_root_folder",
-    "sonarr_qbittorrent_category",
     "radarr_base_url",
     "radarr_api_key",
     "radarr_quality_profile_id",
     "radarr_root_folder",
-    "radarr_qbittorrent_category",
     "prowlarr_base_url",
     "prowlarr_api_key",
     "qbittorrent_base_url",
@@ -80,11 +74,6 @@ SETTING_KEYS: List[str] = [
     "requests_cleanup_time",
     "requests_cleanup_days",
     "requests_data_source",
-    "site_build_number",
-    "site_banner_enabled",
-    "site_banner_message",
-    "site_banner_tone",
-    "site_changelog",
 ]
 
 def _normalize_root_folders(folders: Any) -> List[Dict[str, Any]]:
@@ -102,38 +91,6 @@ def _normalize_root_folders(folders: Any) -> List[Dict[str, Any]]:
     return results
 
 
-async def _hydrate_cache_titles_from_jellyseerr(limit: int) -> int:
-    runtime = get_runtime_settings()
-    client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if not client.configured():
-        return 0
-    missing = get_request_cache_missing_titles(limit)
-    if not missing:
-        return 0
-    hydrated = 0
-    for row in missing:
-        tmdb_id = row.get("tmdb_id")
-        media_type = row.get("media_type")
-        request_id = row.get("request_id")
-        if not tmdb_id or not media_type or not request_id:
-            continue
-        try:
-            title, year = await requests_router._hydrate_title_from_tmdb(
-                client, media_type, tmdb_id
-            )
-        except Exception:
-            logger.warning(
-                "Requests cache title hydrate failed: request_id=%s tmdb_id=%s",
-                request_id,
-                tmdb_id,
-            )
-            continue
-        if title:
-            update_request_cache_title(request_id, title, year)
-            hydrated += 1
-    return hydrated
-
-
 def _normalize_quality_profiles(profiles: Any) -> List[Dict[str, Any]]:
     if not isinstance(profiles, list):
         return []
@@ -278,12 +235,10 @@ async def requests_sync_delta() -> Dict[str, Any]:
 
 
 @router.post("/requests/artwork/prefetch")
-async def requests_artwork_prefetch(only_missing: bool = False) -> Dict[str, Any]:
+async def requests_artwork_prefetch() -> Dict[str, Any]:
     runtime = get_runtime_settings()
     state = await requests_router.start_artwork_prefetch(
-        runtime.jellyseerr_base_url,
+        runtime.jellyseerr_base_url, runtime.jellyseerr_api_key
-        runtime.jellyseerr_api_key,
-        only_missing=only_missing,
     )
     logger.info("Admin triggered artwork prefetch: status=%s", state.get("status"))
     return {"status": "ok", "prefetch": state}
@@ -293,25 +248,6 @@ async def requests_artwork_prefetch(only_missing: bool = False) -> Dict[str, Any
 async def requests_artwork_status() -> Dict[str, Any]:
     return {"status": "ok", "prefetch": requests_router.get_artwork_prefetch_state()}
 
-@router.get("/requests/artwork/summary")
-async def requests_artwork_summary() -> Dict[str, Any]:
-    runtime = get_runtime_settings()
-    cache_mode = (runtime.artwork_cache_mode or "remote").lower()
-    stats = get_request_cache_stats()
-    if cache_mode != "cache":
-        stats["cache_bytes"] = 0
-        stats["cache_files"] = 0
-        stats["missing_artwork"] = 0
-    summary = {
-        "cache_mode": cache_mode,
-        "cache_bytes": stats.get("cache_bytes", 0),
-        "cache_files": stats.get("cache_files", 0),
-        "missing_artwork": stats.get("missing_artwork", 0),
-        "total_requests": stats.get("total_requests", 0),
-        "updated_at": stats.get("updated_at"),
-    }
-    return {"status": "ok", "summary": summary}
-
 
 @router.get("/requests/sync/status")
 async def requests_sync_status() -> Dict[str, Any]:
@@ -338,14 +274,7 @@ async def read_logs(lines: int = 200) -> Dict[str, Any]:
 
 @router.get("/requests/cache")
 async def requests_cache(limit: int = 50) -> Dict[str, Any]:
-    repaired = repair_request_cache_titles()
+    return {"rows": get_request_cache_overview(limit)}
-    if repaired:
-        logger.info("Requests cache titles repaired via settings view: %s", repaired)
-    hydrated = await _hydrate_cache_titles_from_jellyseerr(limit)
-    if hydrated:
-        logger.info("Requests cache titles hydrated via Jellyseerr: %s", hydrated)
-    rows = get_request_cache_overview(limit)
-    return {"rows": rows}
 
 
 @router.post("/branding/logo")

backend/app/routers/auth.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta, timezone
+from secrets import token_urlsafe
 
 from fastapi import APIRouter, HTTPException, status, Depends
 from fastapi.security import OAuth2PasswordRequestForm
@@ -9,55 +9,26 @@ from ..db import (
     set_last_login,
     get_user_by_username,
     set_user_password,
-    set_jellyfin_auth_cache,
-    get_user_activity,
-    get_user_activity_summary,
-    get_user_request_stats,
-    get_global_request_leader,
-    get_global_request_total,
 )
 from ..runtime import get_runtime_settings
 from ..clients.jellyfin import JellyfinClient
 from ..clients.jellyseerr import JellyseerrClient
-from ..security import create_access_token, verify_password
+from ..security import create_access_token
 from ..auth import get_current_user
 
 router = APIRouter(prefix="/auth", tags=["auth"])
 
 
-def _normalize_username(value: str) -> str:
-    return value.strip().lower()
-
-
-def _is_recent_jellyfin_auth(last_auth_at: str) -> bool:
-    if not last_auth_at:
-        return False
-    try:
-        parsed = datetime.fromisoformat(last_auth_at)
-    except ValueError:
-        return False
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    age = datetime.now(timezone.utc) - parsed
-    return age <= timedelta(days=7)
-
-
-def _has_valid_jellyfin_cache(user: dict, password: str) -> bool:
-    if not user or not password:
-        return False
-    cached_hash = user.get("jellyfin_password_hash")
-    last_auth_at = user.get("last_jellyfin_auth_at")
-    if not cached_hash or not last_auth_at:
-        return False
-    if not verify_password(password, cached_hash):
-        return False
-    return _is_recent_jellyfin_auth(last_auth_at)
-
-
 @router.post("/login")
 async def login(form_data: OAuth2PasswordRequestForm = Depends()) -> dict:
     user = verify_user_password(form_data.username, form_data.password)
     if not user:
+        existing = get_user_by_username(form_data.username)
+        if existing and existing.get("auth_provider") != "local":
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Use the {existing.get('auth_provider')} sign-in flow for this account",
+            )
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
     if user.get("is_blocked"):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
@@ -76,25 +47,18 @@ async def jellyfin_login(form_data: OAuth2PasswordRequestForm = Depends()) -> di
     client = JellyfinClient(runtime.jellyfin_base_url, runtime.jellyfin_api_key)
     if not client.configured():
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Jellyfin not configured")
-    username = form_data.username
-    password = form_data.password
-    user = get_user_by_username(username)
-    if user and user.get("is_blocked"):
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
-    if user and _has_valid_jellyfin_cache(user, password):
-        token = create_access_token(username, "user")
-        set_last_login(username)
-        return {"access_token": token, "token_type": "bearer", "user": {"username": username, "role": "user"}}
     try:
-        response = await client.authenticate_by_name(username, password)
+        response = await client.authenticate_by_name(form_data.username, form_data.password)
     except Exception as exc:
         raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
     if not isinstance(response, dict) or not response.get("User"):
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid Jellyfin credentials")
-    create_user_if_missing(username, "jellyfin-user", role="user", auth_provider="jellyfin")
+    create_user_if_missing(form_data.username, token_urlsafe(32), role="user", auth_provider="jellyfin")
-    user = get_user_by_username(username)
+    user = get_user_by_username(form_data.username)
     if user and user.get("is_blocked"):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
+    if user and user.get("auth_provider") == "jellyfin":
+        set_user_password(form_data.username, token_urlsafe(32))
     try:
         users = await client.get_users()
         if isinstance(users, list):
@@ -103,13 +67,12 @@ async def jellyfin_login(form_data: OAuth2PasswordRequestForm = Depends()) -> di
                     continue
                 name = user.get("Name")
                 if isinstance(name, str) and name:
-                    create_user_if_missing(name, "jellyfin-user", role="user", auth_provider="jellyfin")
+                    create_user_if_missing(name, token_urlsafe(32), role="user", auth_provider="jellyfin")
     except Exception:
         pass
-    set_jellyfin_auth_cache(username, password)
+    token = create_access_token(form_data.username, "user")
-    token = create_access_token(username, "user")
+    set_last_login(form_data.username)
-    set_last_login(username)
+    return {"access_token": token, "token_type": "bearer", "user": {"username": form_data.username, "role": "user"}}
-    return {"access_token": token, "token_type": "bearer", "user": {"username": username, "role": "user"}}
 
 
 @router.post("/jellyseerr/login")
@@ -125,10 +88,12 @@ async def jellyseerr_login(form_data: OAuth2PasswordRequestForm = Depends()) ->
         raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc)) from exc
     if not isinstance(response, dict):
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid Jellyseerr credentials")
-    create_user_if_missing(form_data.username, "jellyseerr-user", role="user", auth_provider="jellyseerr")
+    create_user_if_missing(form_data.username, token_urlsafe(32), role="user", auth_provider="jellyseerr")
     user = get_user_by_username(form_data.username)
     if user and user.get("is_blocked"):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="User is blocked")
+    if user and user.get("auth_provider") == "jellyseerr":
+        set_user_password(form_data.username, token_urlsafe(32))
     token = create_access_token(form_data.username, "user")
     set_last_login(form_data.username)
     return {"access_token": token, "token_type": "bearer", "user": {"username": form_data.username, "role": "user"}}
@@ -139,32 +104,6 @@ async def me(current_user: dict = Depends(get_current_user)) -> dict:
     return current_user
 
 
-@router.get("/profile")
-async def profile(current_user: dict = Depends(get_current_user)) -> dict:
-    username = current_user.get("username") or ""
-    username_norm = _normalize_username(username) if username else ""
-    stats = get_user_request_stats(username_norm)
-    global_total = get_global_request_total()
-    share = (stats.get("total", 0) / global_total) if global_total else 0
-    activity_summary = get_user_activity_summary(username) if username else {}
-    activity_recent = get_user_activity(username, limit=5) if username else []
-    stats_payload = {
-        **stats,
-        "share": share,
-        "global_total": global_total,
-    }
-    if current_user.get("role") == "admin":
-        stats_payload["most_active_user"] = get_global_request_leader()
-    return {
-        "user": current_user,
-        "stats": stats_payload,
-        "activity": {
-            **activity_summary,
-            "recent": activity_recent,
-        },
-    }
-
-
 @router.post("/password")
 async def change_password(payload: dict, current_user: dict = Depends(get_current_user)) -> dict:
     if current_user.get("auth_provider") != "local":

backend/app/routers/branding.py

@@ -11,10 +11,6 @@ router = APIRouter(prefix="/branding", tags=["branding"])
 _BRANDING_DIR = os.path.join(os.getcwd(), "data", "branding")
 _LOGO_PATH = os.path.join(_BRANDING_DIR, "logo.png")
 _FAVICON_PATH = os.path.join(_BRANDING_DIR, "favicon.ico")
-_BUNDLED_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "assets", "branding"))
-_BUNDLED_LOGO_PATH = os.path.join(_BUNDLED_DIR, "logo.png")
-_BUNDLED_FAVICON_PATH = os.path.join(_BUNDLED_DIR, "favicon.ico")
-_BRANDING_SOURCE = os.getenv("BRANDING_SOURCE", "bundled").lower()
 
 
 def _ensure_branding_dir() -> None:
@@ -45,18 +41,6 @@ def _ensure_default_branding() -> None:
     if os.path.exists(_LOGO_PATH) and os.path.exists(_FAVICON_PATH):
         return
     _ensure_branding_dir()
-    if not os.path.exists(_LOGO_PATH) and os.path.exists(_BUNDLED_LOGO_PATH):
-        try:
-            with open(_BUNDLED_LOGO_PATH, "rb") as source, open(_LOGO_PATH, "wb") as target:
-                target.write(source.read())
-        except OSError:
-            pass
-    if not os.path.exists(_FAVICON_PATH) and os.path.exists(_BUNDLED_FAVICON_PATH):
-        try:
-            with open(_BUNDLED_FAVICON_PATH, "rb") as source, open(_FAVICON_PATH, "wb") as target:
-                target.write(source.read())
-        except OSError:
-            pass
     if not os.path.exists(_LOGO_PATH):
         image = Image.new("RGBA", (300, 300), (12, 18, 28, 255))
         draw = ImageDraw.Draw(image)
@@ -81,32 +65,24 @@ def _ensure_default_branding() -> None:
             favicon.save(_FAVICON_PATH, format="ICO")
 
 
-def _resolve_branding_paths() -> tuple[str, str]:
-    if _BRANDING_SOURCE == "data":
-        _ensure_default_branding()
-        return _LOGO_PATH, _FAVICON_PATH
-    if os.path.exists(_BUNDLED_LOGO_PATH) and os.path.exists(_BUNDLED_FAVICON_PATH):
-        return _BUNDLED_LOGO_PATH, _BUNDLED_FAVICON_PATH
-    _ensure_default_branding()
-    return _LOGO_PATH, _FAVICON_PATH
-
-
 @router.get("/logo.png")
 async def branding_logo() -> FileResponse:
-    logo_path, _ = _resolve_branding_paths()
+    if not os.path.exists(_LOGO_PATH):
-    if not os.path.exists(logo_path):
+        _ensure_default_branding()
+    if not os.path.exists(_LOGO_PATH):
         raise HTTPException(status_code=404, detail="Logo not found")
-    headers = {"Cache-Control": "no-store"}
+    headers = {"Cache-Control": "public, max-age=300"}
-    return FileResponse(logo_path, media_type="image/png", headers=headers)
+    return FileResponse(_LOGO_PATH, media_type="image/png", headers=headers)
 
 
 @router.get("/favicon.ico")
 async def branding_favicon() -> FileResponse:
-    _, favicon_path = _resolve_branding_paths()
+    if not os.path.exists(_FAVICON_PATH):
-    if not os.path.exists(favicon_path):
+        _ensure_default_branding()
+    if not os.path.exists(_FAVICON_PATH):
         raise HTTPException(status_code=404, detail="Favicon not found")
-    headers = {"Cache-Control": "no-store"}
+    headers = {"Cache-Control": "public, max-age=300"}
-    return FileResponse(favicon_path, media_type="image/x-icon", headers=headers)
+    return FileResponse(_FAVICON_PATH, media_type="image/x-icon", headers=headers)
 
 
 async def save_branding_image(file: UploadFile) -> Dict[str, Any]:

backend/app/routers/images.py

@@ -1,8 +1,6 @@
 import os
 import re
 import mimetypes
-import logging
-from typing import Optional
 from fastapi import APIRouter, HTTPException, Response
 from fastapi.responses import FileResponse, RedirectResponse
 import httpx
@@ -13,7 +11,6 @@ router = APIRouter(prefix="/images", tags=["images"])
 
 _TMDB_BASE = "https://image.tmdb.org/t/p"
 _ALLOWED_SIZES = {"w92", "w154", "w185", "w342", "w500", "w780", "original"}
-logger = logging.getLogger(__name__)
 
 
 def _safe_filename(path: str) -> str:
@@ -22,35 +19,23 @@ def _safe_filename(path: str) -> str:
     safe = re.sub(r"[^A-Za-z0-9_.-]", "_", trimmed)
     return safe or "image"
 
-def tmdb_cache_path(path: str, size: str) -> Optional[str]:
-    if not path or "://" in path or ".." in path:
-        return None
-    if not path.startswith("/"):
-        path = f"/{path}"
-    if size not in _ALLOWED_SIZES:
-        return None
-    cache_dir = os.path.join(os.getcwd(), "data", "artwork", "tmdb", size)
-    return os.path.join(cache_dir, _safe_filename(path))
-
-
-def is_tmdb_cached(path: str, size: str) -> bool:
-    file_path = tmdb_cache_path(path, size)
-    return bool(file_path and os.path.exists(file_path))
-
 
 async def cache_tmdb_image(path: str, size: str = "w342") -> bool:
     if not path or "://" in path or ".." in path:
         return False
+    if not path.startswith("/"):
+        path = f"/{path}"
+    if size not in _ALLOWED_SIZES:
+        return False
 
     runtime = get_runtime_settings()
     cache_mode = (runtime.artwork_cache_mode or "remote").lower()
     if cache_mode != "cache":
         return False
 
-    file_path = tmdb_cache_path(path, size)
+    cache_dir = os.path.join(os.getcwd(), "data", "artwork", "tmdb", size)
-    if not file_path:
+    os.makedirs(cache_dir, exist_ok=True)
-        return False
+    file_path = os.path.join(cache_dir, _safe_filename(path))
-    os.makedirs(os.path.dirname(file_path), exist_ok=True)
     if os.path.exists(file_path):
         return True
 
@@ -79,10 +64,9 @@ async def tmdb_image(path: str, size: str = "w342"):
     if cache_mode != "cache":
         return RedirectResponse(url=url)
 
-    file_path = tmdb_cache_path(path, size)
+    cache_dir = os.path.join(os.getcwd(), "data", "artwork", "tmdb", size)
-    if not file_path:
+    os.makedirs(cache_dir, exist_ok=True)
-        raise HTTPException(status_code=400, detail="Invalid image path")
+    file_path = os.path.join(cache_dir, _safe_filename(path))
-    os.makedirs(os.path.dirname(file_path), exist_ok=True)
     headers = {"Cache-Control": "public, max-age=86400"}
     if os.path.exists(file_path):
         media_type = mimetypes.guess_type(file_path)[0] or "image/jpeg"
@@ -93,8 +77,6 @@ async def tmdb_image(path: str, size: str = "w342"):
         if os.path.exists(file_path):
             media_type = mimetypes.guess_type(file_path)[0] or "image/jpeg"
             return FileResponse(file_path, media_type=media_type, headers=headers)
-        logger.warning("TMDB cache miss after fetch: path=%s size=%s", path, size)
+        raise HTTPException(status_code=502, detail="Image cache failed")
-    except (httpx.HTTPError, OSError) as exc:
+    except httpx.HTTPError as exc:
-        logger.warning("TMDB cache failed: path=%s size=%s error=%s", path, size, exc)
+        raise HTTPException(status_code=502, detail=f"Image fetch failed: {exc}") from exc
-
-    return RedirectResponse(url=url)

backend/app/routers/requests.py

@@ -3,7 +3,6 @@ import asyncio
 import httpx
 import json
 import logging
-import os
 import time
 from urllib.parse import quote
 from datetime import datetime, timezone, timedelta
@@ -18,7 +17,7 @@ from ..clients.prowlarr import ProwlarrClient
 from ..ai.triage import triage_snapshot
 from ..auth import get_current_user
 from ..runtime import get_runtime_settings
-from .images import cache_tmdb_image, is_tmdb_cached
+from .images import cache_tmdb_image
 from ..db import (
     save_action,
     get_recent_actions,
@@ -31,16 +30,10 @@ from ..db import (
     get_request_cache_last_updated,
     get_request_cache_count,
     get_request_cache_payloads,
-    get_request_cache_payloads_missing,
-    repair_request_cache_titles,
     prune_duplicate_requests_cache,
     upsert_request_cache,
-    upsert_artwork_cache_status,
-    get_artwork_cache_missing_count,
-    get_artwork_cache_status_count,
     get_setting,
     set_setting,
-    update_artwork_cache_stats,
     cleanup_history,
 )
 from ..models import Snapshot, TriageResult, RequestType
@@ -71,12 +64,10 @@ _artwork_prefetch_state: Dict[str, Any] = {
     "processed": 0,
     "total": 0,
     "message": "",
-    "only_missing": False,
     "started_at": None,
     "finished_at": None,
 }
 _artwork_prefetch_task: Optional[asyncio.Task] = None
-_media_endpoint_supported: Optional[bool] = None
 
 STATUS_LABELS = {
     1: "Waiting for approval",
@@ -234,108 +225,6 @@ def _extract_artwork_paths(item: Dict[str, Any]) -> tuple[Optional[str], Optiona
         backdrop_path = item.get("backdropPath") or item.get("backdrop_path")
     return poster_path, backdrop_path
 
-def _extract_tmdb_lookup(payload: Dict[str, Any]) -> tuple[Optional[int], Optional[str]]:
-    media = payload.get("media") or {}
-    if not isinstance(media, dict):
-        media = {}
-    tmdb_id = media.get("tmdbId") or payload.get("tmdbId")
-    media_type = (
-        media.get("mediaType")
-        or payload.get("mediaType")
-        or payload.get("type")
-    )
-    try:
-        tmdb_id = int(tmdb_id) if tmdb_id is not None else None
-    except (TypeError, ValueError):
-        tmdb_id = None
-    if isinstance(media_type, str):
-        media_type = media_type.strip().lower() or None
-    else:
-        media_type = None
-    return tmdb_id, media_type
-
-
-def _artwork_missing_for_payload(payload: Dict[str, Any]) -> bool:
-    poster_path, backdrop_path = _extract_artwork_paths(payload)
-    tmdb_id, media_type = _extract_tmdb_lookup(payload)
-    can_hydrate = bool(tmdb_id and media_type)
-    if poster_path:
-        if not is_tmdb_cached(poster_path, "w185") or not is_tmdb_cached(poster_path, "w342"):
-            return True
-    elif can_hydrate:
-        return True
-    if backdrop_path:
-        if not is_tmdb_cached(backdrop_path, "w780"):
-            return True
-    elif can_hydrate:
-        return True
-    return False
-
-
-def _compute_cached_flags(
-    poster_path: Optional[str],
-    backdrop_path: Optional[str],
-    cache_mode: str,
-    poster_cached: Optional[bool] = None,
-    backdrop_cached: Optional[bool] = None,
-) -> tuple[bool, bool]:
-    if cache_mode != "cache":
-        return True, True
-    poster = poster_cached
-    backdrop = backdrop_cached
-    if poster is None:
-        poster = bool(poster_path) and is_tmdb_cached(poster_path, "w185") and is_tmdb_cached(
-            poster_path, "w342"
-        )
-    if backdrop is None:
-        backdrop = bool(backdrop_path) and is_tmdb_cached(backdrop_path, "w780")
-    return bool(poster), bool(backdrop)
-
-
-def _upsert_artwork_status(
-    payload: Dict[str, Any],
-    cache_mode: str,
-    poster_cached: Optional[bool] = None,
-    backdrop_cached: Optional[bool] = None,
-) -> None:
-    parsed = _parse_request_payload(payload)
-    request_id = parsed.get("request_id")
-    if not isinstance(request_id, int):
-        return
-    tmdb_id, media_type = _extract_tmdb_lookup(payload)
-    poster_path, backdrop_path = _extract_artwork_paths(payload)
-    has_tmdb = bool(tmdb_id and media_type)
-    poster_cached_flag, backdrop_cached_flag = _compute_cached_flags(
-        poster_path, backdrop_path, cache_mode, poster_cached, backdrop_cached
-    )
-    upsert_artwork_cache_status(
-        request_id=request_id,
-        tmdb_id=tmdb_id,
-        media_type=media_type,
-        poster_path=poster_path,
-        backdrop_path=backdrop_path,
-        has_tmdb=has_tmdb,
-        poster_cached=poster_cached_flag,
-        backdrop_cached=backdrop_cached_flag,
-    )
-
-
-def _collect_artwork_cache_disk_stats() -> tuple[int, int]:
-    cache_root = os.path.join(os.getcwd(), "data", "artwork")
-    total_bytes = 0
-    total_files = 0
-    if not os.path.isdir(cache_root):
-        return 0, 0
-    for root, _, files in os.walk(cache_root):
-        for name in files:
-            path = os.path.join(root, name)
-            try:
-                total_bytes += os.path.getsize(path)
-                total_files += 1
-            except OSError:
-                continue
-    return total_bytes, total_files
-
 
 async def _get_request_details(client: JellyseerrClient, request_id: int) -> Optional[Dict[str, Any]]:
     cache_key = f"request:{request_id}"
@@ -380,17 +269,10 @@ async def _hydrate_title_from_tmdb(
 async def _hydrate_media_details(client: JellyseerrClient, media_id: Optional[int]) -> Optional[Dict[str, Any]]:
     if not media_id:
         return None
-    global _media_endpoint_supported
-    if _media_endpoint_supported is False:
-        return None
     try:
         details = await client.get_media(int(media_id))
-    except httpx.HTTPStatusError as exc:
+    except httpx.HTTPStatusError:
-        if exc.response is not None and exc.response.status_code == 405:
-            _media_endpoint_supported = False
-            logger.info("Jellyseerr media endpoint rejected GET requests; skipping media lookups.")
         return None
-    _media_endpoint_supported = True
     return details if isinstance(details, dict) else None
 
 
@@ -511,23 +393,14 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
                 continue
             payload = _parse_request_payload(item)
             request_id = payload.get("request_id")
-            cached_title = None
             if isinstance(request_id, int):
-                if not payload.get("title"):
-                    cached = get_request_cache_by_id(request_id)
-                    if cached and cached.get("title"):
-                        cached_title = cached.get("title")
                 if not payload.get("title") or not payload.get("media_id"):
                     logger.debug("Jellyseerr sync hydrate request_id=%s", request_id)
                     details = await _get_request_details(client, request_id)
                     if isinstance(details, dict):
                         payload = _parse_request_payload(details)
                         item = details
-                if (
+                if not payload.get("title") and payload.get("media_id"):
-                    not payload.get("title")
-                    and payload.get("media_id")
-                    and (not payload.get("tmdb_id") or not payload.get("media_type"))
-                ):
                     media_details = await _hydrate_media_details(client, payload.get("media_id"))
                     if isinstance(media_details, dict):
                         media_title = media_details.get("title") or media_details.get("name")
@@ -555,7 +428,7 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
                     if isinstance(details, dict):
                         item = details
                         payload = _parse_request_payload(details)
-                if not payload.get("title") and payload.get("tmdb_id") and payload.get("media_type"):
+                if not payload.get("title") and payload.get("tmdb_id"):
                     hydrated_title, hydrated_year = await _hydrate_title_from_tmdb(
                         client, payload.get("media_type"), payload.get("tmdb_id")
                     )
@@ -563,8 +436,6 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
                         payload["title"] = hydrated_title
                     if hydrated_year:
                         payload["year"] = hydrated_year
-                if not payload.get("title") and cached_title:
-                    payload["title"] = cached_title
             if not isinstance(payload.get("request_id"), int):
                 continue
             payload_json = json.dumps(item, ensure_ascii=True)
@@ -581,8 +452,6 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
                 updated_at=payload.get("updated_at"),
                 payload_json=payload_json,
             )
-            if isinstance(item, dict):
-                _upsert_artwork_status(item, cache_mode)
             stored += 1
             _sync_state["stored"] = stored
         if len(items) < take:
@@ -602,11 +471,6 @@ async def _sync_all_requests(client: JellyseerrClient) -> int:
     )
     set_setting(_sync_last_key, datetime.now(timezone.utc).isoformat())
     _refresh_recent_cache_from_db()
-    if cache_mode == "cache":
-        update_artwork_cache_stats(
-            missing_count=get_artwork_cache_missing_count(),
-            total_requests=get_request_cache_count(),
-        )
     return stored
 
 
@@ -652,7 +516,6 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
             if isinstance(request_id, int):
                 cached = get_request_cache_by_id(request_id)
                 incoming_updated = payload.get("updated_at")
-                cached_title = cached.get("title") if cached else None
                 if cached and incoming_updated and cached.get("updated_at") == incoming_updated and cached.get("title"):
                     continue
                 if not payload.get("title") or not payload.get("media_id"):
@@ -660,11 +523,7 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
                     if isinstance(details, dict):
                         payload = _parse_request_payload(details)
                         item = details
-                if (
+                if not payload.get("title") and payload.get("media_id"):
-                    not payload.get("title")
-                    and payload.get("media_id")
-                    and (not payload.get("tmdb_id") or not payload.get("media_type"))
-                ):
                     media_details = await _hydrate_media_details(client, payload.get("media_id"))
                     if isinstance(media_details, dict):
                         media_title = media_details.get("title") or media_details.get("name")
@@ -692,7 +551,7 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
                     if isinstance(details, dict):
                         payload = _parse_request_payload(details)
                         item = details
-                if not payload.get("title") and payload.get("tmdb_id") and payload.get("media_type"):
+                if not payload.get("title") and payload.get("tmdb_id"):
                     hydrated_title, hydrated_year = await _hydrate_title_from_tmdb(
                         client, payload.get("media_type"), payload.get("tmdb_id")
                     )
@@ -700,8 +559,6 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
                         payload["title"] = hydrated_title
                     if hydrated_year:
                         payload["year"] = hydrated_year
-                if not payload.get("title") and cached_title:
-                    payload["title"] = cached_title
             if not isinstance(payload.get("request_id"), int):
                 continue
             payload_json = json.dumps(item, ensure_ascii=True)
@@ -718,8 +575,6 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
                 updated_at=payload.get("updated_at"),
                 payload_json=payload_json,
             )
-            if isinstance(item, dict):
-                _upsert_artwork_status(item, cache_mode)
             stored += 1
             page_changed = True
             _sync_state["stored"] = stored
@@ -747,20 +602,10 @@ async def _sync_delta_requests(client: JellyseerrClient) -> int:
     )
     set_setting(_sync_last_key, datetime.now(timezone.utc).isoformat())
     _refresh_recent_cache_from_db()
-    if cache_mode == "cache":
-        update_artwork_cache_stats(
-            missing_count=get_artwork_cache_missing_count(),
-            total_requests=get_request_cache_count(),
-        )
     return stored
 
 
-async def _prefetch_artwork_cache(
+async def _prefetch_artwork_cache(client: JellyseerrClient) -> None:
-    client: JellyseerrClient,
-    only_missing: bool = False,
-    total: Optional[int] = None,
-    use_missing_query: bool = False,
-) -> None:
     runtime = get_runtime_settings()
     cache_mode = (runtime.artwork_cache_mode or "remote").lower()
     if cache_mode != "cache":
@@ -773,100 +618,74 @@ async def _prefetch_artwork_cache(
         )
         return
 
-    total = total if total is not None else get_request_cache_count()
+    total = get_request_cache_count()
     _artwork_prefetch_state.update(
         {
             "status": "running",
             "processed": 0,
             "total": total,
-            "message": "Starting missing artwork prefetch"
+            "message": "Starting artwork prefetch",
-            if only_missing
-            else "Starting artwork prefetch",
-            "only_missing": only_missing,
             "started_at": datetime.now(timezone.utc).isoformat(),
             "finished_at": None,
         }
     )
-    if only_missing and total == 0:
-        _artwork_prefetch_state.update(
-            {
-                "status": "completed",
-                "processed": 0,
-                "message": "No missing artwork to cache.",
-                "finished_at": datetime.now(timezone.utc).isoformat(),
-            }
-        )
-        return
     offset = 0
     limit = 200
     processed = 0
     while True:
-        if use_missing_query:
+        batch = get_request_cache_payloads(limit=limit, offset=offset)
-            batch = get_request_cache_payloads_missing(limit=limit, offset=offset)
-        else:
-            batch = get_request_cache_payloads(limit=limit, offset=offset)
         if not batch:
             break
         for row in batch:
             payload = row.get("payload")
             if not isinstance(payload, dict):
-                if not only_missing:
+                processed += 1
-                    processed += 1
-                continue
-            if only_missing and not use_missing_query and not _artwork_missing_for_payload(payload):
                 continue
             poster_path, backdrop_path = _extract_artwork_paths(payload)
-            tmdb_id, media_type = _extract_tmdb_lookup(payload)
+            if not (poster_path or backdrop_path) and client.configured():
-            if (not poster_path or not backdrop_path) and client.configured() and tmdb_id and media_type:
                 media = payload.get("media") or {}
-                hydrated_poster, hydrated_backdrop = await _hydrate_artwork_from_tmdb(
+                tmdb_id = media.get("tmdbId") or payload.get("tmdbId")
-                    client, media_type, tmdb_id
+                media_type = media.get("mediaType") or payload.get("type")
-                )
+                if tmdb_id and media_type:
-                poster_path = poster_path or hydrated_poster
+                    hydrated_poster, hydrated_backdrop = await _hydrate_artwork_from_tmdb(
-                backdrop_path = backdrop_path or hydrated_backdrop
+                        client, media_type, tmdb_id
-                if hydrated_poster or hydrated_backdrop:
+                    )
-                    media = dict(media) if isinstance(media, dict) else {}
+                    poster_path = poster_path or hydrated_poster
-                    if hydrated_poster:
+                    backdrop_path = backdrop_path or hydrated_backdrop
-                        media["posterPath"] = hydrated_poster
+                    if hydrated_poster or hydrated_backdrop:
-                    if hydrated_backdrop:
+                        media = dict(media) if isinstance(media, dict) else {}
-                        media["backdropPath"] = hydrated_backdrop
+                        if hydrated_poster:
-                    payload["media"] = media
+                            media["posterPath"] = hydrated_poster
-                    parsed = _parse_request_payload(payload)
+                        if hydrated_backdrop:
-                    request_id = parsed.get("request_id")
+                            media["backdropPath"] = hydrated_backdrop
-                    if isinstance(request_id, int):
+                        payload["media"] = media
-                        upsert_request_cache(
+                        parsed = _parse_request_payload(payload)
-                            request_id=request_id,
+                        request_id = parsed.get("request_id")
-                            media_id=parsed.get("media_id"),
+                        if isinstance(request_id, int):
-                            media_type=parsed.get("media_type"),
+                            upsert_request_cache(
-                            status=parsed.get("status"),
+                                request_id=request_id,
-                            title=parsed.get("title"),
+                                media_id=parsed.get("media_id"),
-                            year=parsed.get("year"),
+                                media_type=parsed.get("media_type"),
-                            requested_by=parsed.get("requested_by"),
+                                status=parsed.get("status"),
-                            requested_by_norm=parsed.get("requested_by_norm"),
+                                title=parsed.get("title"),
-                            created_at=parsed.get("created_at"),
+                                year=parsed.get("year"),
-                            updated_at=parsed.get("updated_at"),
+                                requested_by=parsed.get("requested_by"),
-                            payload_json=json.dumps(payload, ensure_ascii=True),
+                                requested_by_norm=parsed.get("requested_by_norm"),
-                        )
+                                created_at=parsed.get("created_at"),
-            poster_cached_flag = False
+                                updated_at=parsed.get("updated_at"),
-            backdrop_cached_flag = False
+                                payload_json=json.dumps(payload, ensure_ascii=True),
+                            )
             if poster_path:
                 try:
-                    poster_cached_flag = bool(
+                    await cache_tmdb_image(poster_path, "w185")
-                        await cache_tmdb_image(poster_path, "w185")
+                    await cache_tmdb_image(poster_path, "w342")
-                    ) and bool(await cache_tmdb_image(poster_path, "w342"))
                 except httpx.HTTPError:
-                    poster_cached_flag = False
+                    pass
             if backdrop_path:
                 try:
-                    backdrop_cached_flag = bool(await cache_tmdb_image(backdrop_path, "w780"))
+                    await cache_tmdb_image(backdrop_path, "w780")
                 except httpx.HTTPError:
-                    backdrop_cached_flag = False
+                    pass
-            _upsert_artwork_status(
-                payload,
-                cache_mode,
-                poster_cached=poster_cached_flag if poster_path else None,
-                backdrop_cached=backdrop_cached_flag if backdrop_path else None,
-            )
             processed += 1
             if processed % 25 == 0:
                 _artwork_prefetch_state.update(
@@ -874,15 +693,6 @@ async def _prefetch_artwork_cache(
                 )
         offset += limit
 
-    total_requests = get_request_cache_count()
-    missing_count = get_artwork_cache_missing_count()
-    cache_bytes, cache_files = _collect_artwork_cache_disk_stats()
-    update_artwork_cache_stats(
-        cache_bytes=cache_bytes,
-        cache_files=cache_files,
-        missing_count=missing_count,
-        total_requests=total_requests,
-    )
     _artwork_prefetch_state.update(
         {
             "status": "completed",
@@ -893,52 +703,25 @@ async def _prefetch_artwork_cache(
     )
 
 
-async def start_artwork_prefetch(
+async def start_artwork_prefetch(base_url: Optional[str], api_key: Optional[str]) -> Dict[str, Any]:
-    base_url: Optional[str], api_key: Optional[str], only_missing: bool = False
-) -> Dict[str, Any]:
     global _artwork_prefetch_task
     if _artwork_prefetch_task and not _artwork_prefetch_task.done():
         return dict(_artwork_prefetch_state)
     client = JellyseerrClient(base_url, api_key)
-    status_count = get_artwork_cache_status_count()
-    total_requests = get_request_cache_count()
-    use_missing_query = only_missing and status_count >= total_requests and total_requests > 0
-    if only_missing and use_missing_query:
-        total = get_artwork_cache_missing_count()
-    else:
-        total = total_requests
     _artwork_prefetch_state.update(
         {
             "status": "running",
             "processed": 0,
-            "total": total,
+            "total": get_request_cache_count(),
-            "message": "Seeding artwork cache status"
+            "message": "Starting artwork prefetch",
-            if only_missing and not use_missing_query
-            else ("Starting missing artwork prefetch" if only_missing else "Starting artwork prefetch"),
-            "only_missing": only_missing,
             "started_at": datetime.now(timezone.utc).isoformat(),
             "finished_at": None,
         }
     )
-    if only_missing and total == 0:
-        _artwork_prefetch_state.update(
-            {
-                "status": "completed",
-                "processed": 0,
-                "message": "No missing artwork to cache.",
-                "finished_at": datetime.now(timezone.utc).isoformat(),
-            }
-        )
-        return dict(_artwork_prefetch_state)
 
     async def _runner() -> None:
         try:
-            await _prefetch_artwork_cache(
+            await _prefetch_artwork_cache(client)
-                client,
-                only_missing=only_missing,
-                total=total,
-                use_missing_query=use_missing_query,
-            )
         except Exception:
             logger.exception("Artwork prefetch failed")
             _artwork_prefetch_state.update(
@@ -1005,14 +788,13 @@ def _get_recent_from_cache(
 async def startup_warmup_requests_cache() -> None:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    if not client.configured():
-        try:
+        return
-            await _ensure_requests_cache(client)
+    try:
-        except httpx.HTTPError as exc:
+        await _ensure_requests_cache(client)
-            logger.warning("Requests warmup skipped: %s", exc)
+    except httpx.HTTPError as exc:
-    repaired = repair_request_cache_titles()
+        logger.warning("Requests warmup skipped: %s", exc)
-    if repaired:
+        return
-        logger.info("Requests cache titles repaired: %s", repaired)
     _refresh_recent_cache_from_db()
 
 
@@ -1157,18 +939,15 @@ async def _ensure_request_access(
 ) -> None:
     if user.get("role") == "admin":
         return
-    runtime = get_runtime_settings()
-    mode = (runtime.requests_data_source or "prefer_cache").lower()
     cached = get_request_cache_payload(request_id)
-    if mode != "always_js":
+    if cached is not None:
-        if cached is None:
+        logger.debug("access cache hit: request_id=%s", request_id)
-            logger.debug("access cache miss: request_id=%s mode=%s", request_id, mode)
-            raise HTTPException(status_code=404, detail="Request not found in cache")
-        logger.debug("access cache hit: request_id=%s mode=%s", request_id, mode)
         if _request_matches_user(cached, user.get("username", "")):
             return
         raise HTTPException(status_code=403, detail="Request not accessible for this user")
-    logger.debug("access cache miss: request_id=%s mode=%s", request_id, mode)
+    if not client.configured():
+        raise HTTPException(status_code=403, detail="Request access cannot be verified")
+    logger.debug("access cache miss: request_id=%s", request_id)
     details = await _get_request_details(client, request_id)
     if details is None or not _request_matches_user(details, user.get("username", "")):
         raise HTTPException(status_code=403, detail="Request not accessible for this user")
@@ -1220,148 +999,6 @@ def _normalize_categories(categories: Any) -> List[str]:
     return names
 
 
-def _normalize_indexer_name(value: Optional[str]) -> str:
-    if not isinstance(value, str):
-        return ""
-    return "".join(ch for ch in value.lower().strip() if ch.isalnum())
-
-
-def _log_arr_http_error(service_label: str, action: str, exc: httpx.HTTPStatusError) -> None:
-    if exc.response is None:
-        logger.warning("%s %s failed: %s", service_label, action, exc)
-        return
-    status = exc.response.status_code
-    body = exc.response.text
-    if isinstance(body, str):
-        body = body.strip()
-        if len(body) > 800:
-            body = f"{body[:800]}...(truncated)"
-    logger.warning("%s %s failed: status=%s body=%s", service_label, action, status, body)
-
-
-def _format_rejections(rejections: Any) -> Optional[str]:
-    if isinstance(rejections, str):
-        return rejections.strip() or None
-    if isinstance(rejections, list):
-        reasons = []
-        for item in rejections:
-            reason = None
-            if isinstance(item, dict):
-                reason = (
-                    item.get("reason")
-                    or item.get("message")
-                    or item.get("errorMessage")
-                )
-            if not reason and item is not None:
-                reason = str(item)
-            if isinstance(reason, str) and reason.strip():
-                reasons.append(reason.strip())
-        if reasons:
-            return "; ".join(reasons)
-    return None
-
-
-def _release_push_accepted(response: Any) -> tuple[bool, Optional[str]]:
-    if not isinstance(response, dict):
-        return True, None
-    rejections = response.get("rejections") or response.get("rejectionReasons")
-    reason = _format_rejections(rejections)
-    if reason:
-        return False, reason
-    if response.get("rejected") is True:
-        return False, "rejected"
-    if response.get("downloadAllowed") is False:
-        return False, "download not allowed"
-    if response.get("approved") is False:
-        return False, "not approved"
-    return True, None
-
-
-def _resolve_arr_indexer_id(
-    indexers: Any, indexer_name: Optional[str], indexer_id: Optional[int], service_label: str
-) -> Optional[int]:
-    if not isinstance(indexers, list):
-        return None
-    if not indexer_name:
-        if indexer_id is None:
-            return None
-        by_id = next(
-            (item for item in indexers if isinstance(item, dict) and item.get("id") == indexer_id),
-            None,
-        )
-        if by_id and by_id.get("id") is not None:
-            logger.debug("%s indexer id match: %s", service_label, by_id.get("id"))
-            return int(by_id["id"])
-        return None
-    target = indexer_name.lower().strip()
-    target_compact = _normalize_indexer_name(indexer_name)
-    exact = next(
-        (
-            item
-            for item in indexers
-            if isinstance(item, dict)
-            and str(item.get("name", "")).lower().strip() == target
-        ),
-        None,
-    )
-    if exact and exact.get("id") is not None:
-        logger.debug("%s indexer match: '%s' -> %s", service_label, indexer_name, exact.get("id"))
-        return int(exact["id"])
-    compact = next(
-        (
-            item
-            for item in indexers
-            if isinstance(item, dict)
-            and _normalize_indexer_name(str(item.get("name", ""))) == target_compact
-        ),
-        None,
-    )
-    if compact and compact.get("id") is not None:
-        logger.debug("%s indexer compact match: '%s' -> %s", service_label, indexer_name, compact.get("id"))
-        return int(compact["id"])
-    contains = next(
-        (
-            item
-            for item in indexers
-            if isinstance(item, dict)
-            and target in str(item.get("name", "")).lower()
-        ),
-        None,
-    )
-    if contains and contains.get("id") is not None:
-        logger.debug("%s indexer contains match: '%s' -> %s", service_label, indexer_name, contains.get("id"))
-        return int(contains["id"])
-    logger.warning(
-        "%s indexer not found for name '%s'. Check indexer names in the Arr app.",
-        service_label,
-        indexer_name,
-    )
-    return None
-
-
-async def _fallback_qbittorrent_download(download_url: Optional[str], category: str) -> bool:
-    if not download_url:
-        return False
-    runtime = get_runtime_settings()
-    client = QBittorrentClient(
-        runtime.qbittorrent_base_url,
-        runtime.qbittorrent_username,
-        runtime.qbittorrent_password,
-    )
-    if not client.configured():
-        return False
-    await client.add_torrent_url(download_url, category=category)
-    return True
-
-
-def _resolve_qbittorrent_category(value: Optional[str], default: str) -> str:
-    if isinstance(value, str):
-        cleaned = value.strip()
-        if cleaned:
-            return cleaned
-    return default
-
-
 def _filter_prowlarr_results(results: Any, request_type: RequestType) -> List[Dict[str, Any]]:
     if not isinstance(results, list):
         return []
@@ -1430,8 +1067,7 @@ async def _resolve_root_folder_path(client: Any, root_folder: str, service_name:
 async def get_snapshot(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> Snapshot:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     return await build_snapshot(request_id)
 
 
@@ -1444,15 +1080,13 @@ async def recent_requests(
 ) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    mode = (runtime.requests_data_source or "prefer_cache").lower()
+    if not client.configured():
-    allow_remote = mode == "always_js"
+        raise HTTPException(status_code=400, detail="Jellyseerr not configured")
-    if allow_remote:
+
-        if not client.configured():
+    try:
-            raise HTTPException(status_code=400, detail="Jellyseerr not configured")
+        await _ensure_requests_cache(client)
-        try:
+    except httpx.HTTPStatusError as exc:
-            await _ensure_requests_cache(client)
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
-        except httpx.HTTPStatusError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
 
     username_norm = _normalize_username(user.get("username", ""))
     requested_by = None if user.get("role") == "admin" else username_norm
@@ -1463,8 +1097,10 @@ async def recent_requests(
         _refresh_recent_cache_from_db()
     rows = _get_recent_from_cache(requested_by, take, skip, since_iso)
     cache_mode = (runtime.artwork_cache_mode or "remote").lower()
-    allow_title_hydrate = False
+    mode = (runtime.requests_data_source or "prefer_cache").lower()
-    allow_artwork_hydrate = allow_remote
+    allow_remote = mode == "always_js"
+    allow_title_hydrate = mode == "prefer_cache"
+    allow_artwork_hydrate = allow_remote or allow_title_hydrate
     jellyfin = JellyfinClient(runtime.jellyfin_base_url, runtime.jellyfin_api_key)
     jellyfin_cache: Dict[str, bool] = {}
 
@@ -1690,8 +1326,7 @@ async def search_requests(
 async def ai_triage(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> TriageResult:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     return triage_snapshot(snapshot)
 
@@ -1700,8 +1335,7 @@ async def ai_triage(request_id: str, user: Dict[str, str] = Depends(get_current_
 async def action_search(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     prowlarr_results: List[Dict[str, Any]] = []
     prowlarr = ProwlarrClient(runtime.prowlarr_base_url, runtime.prowlarr_api_key)
@@ -1731,8 +1365,7 @@ async def action_search(request_id: str, user: Dict[str, str] = Depends(get_curr
 async def action_search_auto(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     arr_item = snapshot.raw.get("arr", {}).get("item")
     if not isinstance(arr_item, dict):
@@ -1781,8 +1414,7 @@ async def action_search_auto(request_id: str, user: Dict[str, str] = Depends(get
 async def action_resume(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     queue = snapshot.raw.get("arr", {}).get("queue")
     download_ids = _download_ids(_queue_records(queue))
@@ -1828,8 +1460,7 @@ async def action_resume(request_id: str, user: Dict[str, str] = Depends(get_curr
 async def action_readd(request_id: str, user: Dict[str, str] = Depends(get_current_user)) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     jelly = snapshot.raw.get("jellyseerr") or {}
     media = jelly.get("media") or {}
@@ -1941,8 +1572,7 @@ async def request_history(
 ) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshots = await asyncio.to_thread(get_recent_snapshots, request_id, limit)
     return {"snapshots": snapshots}
 
@@ -1953,8 +1583,7 @@ async def request_actions(
 ) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     actions = await asyncio.to_thread(get_recent_actions, request_id, limit)
     return {"actions": actions}
 
@@ -1965,47 +1594,82 @@ async def action_grab(
 ) -> dict:
     runtime = get_runtime_settings()
     client = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    if client.configured():
+    await _ensure_request_access(client, int(request_id), user)
-        await _ensure_request_access(client, int(request_id), user)
     snapshot = await build_snapshot(request_id)
     guid = payload.get("guid")
     indexer_id = payload.get("indexerId")
-    indexer_name = payload.get("indexerName") or payload.get("indexer")
     download_url = payload.get("downloadUrl")
-    release_title = payload.get("title")
-    release_size = payload.get("size")
-    release_protocol = payload.get("protocol") or "torrent"
-    release_publish = payload.get("publishDate")
-    release_seeders = payload.get("seeders")
-    release_leechers = payload.get("leechers")
     if not guid or not indexer_id:
         raise HTTPException(status_code=400, detail="Missing guid or indexerId")
 
-    logger.info(
-        "Grab requested: request_id=%s guid=%s indexer_id=%s indexer_name=%s has_download_url=%s has_title=%s",
-        request_id,
-        guid,
-        indexer_id,
-        indexer_name,
-        bool(download_url),
-        bool(release_title),
-    )
-
     runtime = get_runtime_settings()
-    if not download_url:
-        raise HTTPException(status_code=400, detail="Missing downloadUrl")
     if snapshot.request_type.value == "tv":
-        category = _resolve_qbittorrent_category(runtime.sonarr_qbittorrent_category, "sonarr")
+        client = SonarrClient(runtime.sonarr_base_url, runtime.sonarr_api_key)
+        if not client.configured():
+            raise HTTPException(status_code=400, detail="Sonarr not configured")
+        try:
+            response = await client.grab_release(str(guid), int(indexer_id))
+        except httpx.HTTPStatusError as exc:
+            status_code = exc.response.status_code if exc.response is not None else 502
+            if status_code == 404 and download_url:
+                qbit = QBittorrentClient(
+                    runtime.qbittorrent_base_url,
+                    runtime.qbittorrent_username,
+                    runtime.qbittorrent_password,
+                )
+                if not qbit.configured():
+                    raise HTTPException(status_code=400, detail="qBittorrent not configured")
+                try:
+                    await qbit.add_torrent_url(str(download_url), category=f"magent-{request_id}")
+                except httpx.HTTPStatusError as qbit_exc:
+                    raise HTTPException(status_code=502, detail=str(qbit_exc)) from qbit_exc
+                await asyncio.to_thread(
+                    save_action,
+                    request_id,
+                    "grab",
+                    "Grab release",
+                    "ok",
+                    "Sent to qBittorrent via Prowlarr.",
+                )
+                return {"status": "ok", "message": "Sent to qBittorrent.", "via": "qbittorrent"}
+            raise HTTPException(status_code=502, detail=str(exc)) from exc
+        await asyncio.to_thread(
+            save_action, request_id, "grab", "Grab release", "ok", "Grab sent to Sonarr."
+        )
+        return {"status": "ok", "response": response}
     if snapshot.request_type.value == "movie":
-        category = _resolve_qbittorrent_category(runtime.radarr_qbittorrent_category, "radarr")
+        client = RadarrClient(runtime.radarr_base_url, runtime.radarr_api_key)
-    if snapshot.request_type.value not in {"tv", "movie"}:
+        if not client.configured():
-        raise HTTPException(status_code=400, detail="Unknown request type")
+            raise HTTPException(status_code=400, detail="Radarr not configured")
+        try:
+            response = await client.grab_release(str(guid), int(indexer_id))
+        except httpx.HTTPStatusError as exc:
+            status_code = exc.response.status_code if exc.response is not None else 502
+            if status_code == 404 and download_url:
+                qbit = QBittorrentClient(
+                    runtime.qbittorrent_base_url,
+                    runtime.qbittorrent_username,
+                    runtime.qbittorrent_password,
+                )
+                if not qbit.configured():
+                    raise HTTPException(status_code=400, detail="qBittorrent not configured")
+                try:
+                    await qbit.add_torrent_url(str(download_url), category=f"magent-{request_id}")
+                except httpx.HTTPStatusError as qbit_exc:
+                    raise HTTPException(status_code=502, detail=str(qbit_exc)) from qbit_exc
+                await asyncio.to_thread(
+                    save_action,
+                    request_id,
+                    "grab",
+                    "Grab release",
+                    "ok",
+                    "Sent to qBittorrent via Prowlarr.",
+                )
+                return {"status": "ok", "message": "Sent to qBittorrent.", "via": "qbittorrent"}
+            raise HTTPException(status_code=502, detail=str(exc)) from exc
+        await asyncio.to_thread(
+            save_action, request_id, "grab", "Grab release", "ok", "Grab sent to Radarr."
+        )
+        return {"status": "ok", "response": response}
 
-    qbittorrent_added = await _fallback_qbittorrent_download(download_url, category)
+    raise HTTPException(status_code=400, detail="Unknown request type")
-    if not qbittorrent_added:
-        raise HTTPException(status_code=400, detail="Failed to add torrent to qBittorrent")
-    action_message = f"Grab sent to qBittorrent (category {category})."
-    await asyncio.to_thread(
-        save_action, request_id, "grab", "Grab release", "ok", action_message
-    )
-    return {"status": "ok", "response": {"qbittorrent": "queued"}}

backend/app/routers/site.py

@@ -1,39 +0,0 @@
-from typing import Any, Dict
-
-from fastapi import APIRouter, Depends
-
-from ..auth import get_current_user
-from ..runtime import get_runtime_settings
-
-router = APIRouter(prefix="/site", tags=["site"])
-
-_BANNER_TONES = {"info", "warning", "error", "maintenance"}
-
-
-def _build_site_info(include_changelog: bool) -> Dict[str, Any]:
-    runtime = get_runtime_settings()
-    banner_message = (runtime.site_banner_message or "").strip()
-    tone = (runtime.site_banner_tone or "info").strip().lower()
-    if tone not in _BANNER_TONES:
-        tone = "info"
-    info = {
-        "buildNumber": (runtime.site_build_number or "").strip(),
-        "banner": {
-            "enabled": bool(runtime.site_banner_enabled and banner_message),
-            "message": banner_message,
-            "tone": tone,
-        },
-    }
-    if include_changelog:
-        info["changelog"] = (runtime.site_changelog or "").strip()
-    return info
-
-
-@router.get("/public")
-async def site_public() -> Dict[str, Any]:
-    return _build_site_info(False)
-
-
-@router.get("/info")
-async def site_info(user: Dict[str, Any] = Depends(get_current_user)) -> Dict[str, Any]:
-    return _build_site_info(True)

backend/app/routers/status.py

@@ -1,6 +1,7 @@
+import asyncio
 from typing import Any, Dict
 import httpx
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends
 
 from ..auth import get_current_user
 from ..runtime import get_runtime_settings
@@ -38,53 +39,45 @@ async def services_status() -> Dict[str, Any]:
     )
     jellyfin = JellyfinClient(runtime.jellyfin_base_url, runtime.jellyfin_api_key)
 
-    services = []
+    checks = [
-    services.append(
+        _check(
-        await _check(
             "Jellyseerr",
             jellyseerr.configured(),
             lambda: jellyseerr.get_recent_requests(take=1, skip=0),
-        )
+        ),
-    )
+        _check(
-    services.append(
-        await _check(
             "Sonarr",
             sonarr.configured(),
             sonarr.get_system_status,
-        )
+        ),
-    )
+        _check(
-    services.append(
-        await _check(
             "Radarr",
             radarr.configured(),
             radarr.get_system_status,
-        )
+        ),
-    )
+        _check(
-    prowlarr_status = await _check(
+            "Prowlarr",
-        "Prowlarr",
+            prowlarr.configured(),
-        prowlarr.configured(),
+            prowlarr.get_health,
-        prowlarr.get_health,
+        ),
-    )
+        _check(
+            "qBittorrent",
+            qbittorrent.configured(),
+            qbittorrent.get_app_version,
+        ),
+        _check(
+            "Jellyfin",
+            jellyfin.configured(),
+            jellyfin.get_system_info,
+        ),
+    ]
+    services = await asyncio.gather(*checks)
+    prowlarr_status = next(service for service in services if service["name"] == "Prowlarr")
     if prowlarr_status.get("status") == "up":
         health = prowlarr_status.get("detail")
         if isinstance(health, list) and health:
             prowlarr_status["status"] = "degraded"
             prowlarr_status["message"] = "Health warnings"
-    services.append(prowlarr_status)
-    services.append(
-        await _check(
-            "qBittorrent",
-            qbittorrent.configured(),
-            qbittorrent.get_app_version,
-        )
-    )
-    services.append(
-        await _check(
-            "Jellyfin",
-            jellyfin.configured(),
-            jellyfin.get_system_info,
-        )
-    )
 
     overall = "up"
     if any(s.get("status") == "down" for s in services):
@@ -93,42 +86,3 @@ async def services_status() -> Dict[str, Any]:
         overall = "degraded"
 
     return {"overall": overall, "services": services}
-
-
-@router.post("/services/{service}/test")
-async def test_service(service: str) -> Dict[str, Any]:
-    runtime = get_runtime_settings()
-    jellyseerr = JellyseerrClient(runtime.jellyseerr_base_url, runtime.jellyseerr_api_key)
-    sonarr = SonarrClient(runtime.sonarr_base_url, runtime.sonarr_api_key)
-    radarr = RadarrClient(runtime.radarr_base_url, runtime.radarr_api_key)
-    prowlarr = ProwlarrClient(runtime.prowlarr_base_url, runtime.prowlarr_api_key)
-    qbittorrent = QBittorrentClient(
-        runtime.qbittorrent_base_url, runtime.qbittorrent_username, runtime.qbittorrent_password
-    )
-    jellyfin = JellyfinClient(runtime.jellyfin_base_url, runtime.jellyfin_api_key)
-
-    service_key = service.strip().lower()
-    checks = {
-        "jellyseerr": (
-            "Jellyseerr",
-            jellyseerr.configured(),
-            lambda: jellyseerr.get_recent_requests(take=1, skip=0),
-        ),
-        "sonarr": ("Sonarr", sonarr.configured(), sonarr.get_system_status),
-        "radarr": ("Radarr", radarr.configured(), radarr.get_system_status),
-        "prowlarr": ("Prowlarr", prowlarr.configured(), prowlarr.get_health),
-        "qbittorrent": ("qBittorrent", qbittorrent.configured(), qbittorrent.get_app_version),
-        "jellyfin": ("Jellyfin", jellyfin.configured(), jellyfin.get_system_info),
-    }
-
-    if service_key not in checks:
-        raise HTTPException(status_code=404, detail="Unknown service")
-
-    name, configured, func = checks[service_key]
-    result = await _check(name, configured, func)
-    if name == "Prowlarr" and result.get("status") == "up":
-        health = result.get("detail")
-        if isinstance(health, list) and health:
-            result["status"] = "degraded"
-            result["message"] = "Health warnings"
-    return result

backend/app/runtime.py

@@ -12,7 +12,6 @@ _INT_FIELDS = {
 }
 _BOOL_FIELDS = {
     "jellyfin_sync_to_arr",
-    "site_banner_enabled",
 }
 
 

backend/app/security.py

@@ -19,6 +19,8 @@ def verify_password(plain_password: str, hashed_password: str) -> bool:
 
 
 def create_access_token(subject: str, role: str, expires_minutes: Optional[int] = None) -> str:
+    if not settings.jwt_secret:
+        raise ValueError("JWT_SECRET is not configured")
     minutes = expires_minutes or settings.jwt_exp_minutes
     expires = datetime.now(timezone.utc) + timedelta(minutes=minutes)
     payload: Dict[str, Any] = {"sub": subject, "role": role, "exp": expires}
@@ -26,6 +28,8 @@ def create_access_token(subject: str, role: str, expires_minutes: Optional[int]
 
 
 def decode_token(token: str) -> Dict[str, Any]:
+    if not settings.jwt_secret:
+        raise ValueError("JWT_SECRET is not configured")
     return jwt.decode(token, settings.jwt_secret, algorithms=[_ALGORITHM])
 
 

backend/app/services/snapshot.py

@@ -11,21 +11,9 @@ from ..clients.radarr import RadarrClient
 from ..clients.prowlarr import ProwlarrClient
 from ..clients.qbittorrent import QBittorrentClient
 from ..runtime import get_runtime_settings
-from ..db import (
+from ..db import save_snapshot, get_request_cache_payload
-    save_snapshot,
-    get_request_cache_payload,
-    get_request_cache_by_id,
-    get_recent_snapshots,
-    get_setting,
-    set_setting,
-)
 from ..models import ActionOption, NormalizedState, RequestType, Snapshot, TimelineHop
 
-logger = logging.getLogger(__name__)
-
-JELLYFIN_SCAN_COOLDOWN_SECONDS = 300
-_jellyfin_scan_key = "jellyfin_scan_last_at"
-
 
 STATUS_LABELS = {
     1: "Waiting for approval",
@@ -53,35 +41,6 @@ def _pick_first(value: Any) -> Optional[Dict[str, Any]]:
     return None
 
 
-async def _maybe_refresh_jellyfin(snapshot: Snapshot) -> None:
-    if snapshot.state not in {NormalizedState.available, NormalizedState.completed}:
-        return
-    runtime = get_runtime_settings()
-    client = JellyfinClient(runtime.jellyfin_base_url, runtime.jellyfin_api_key)
-    if not client.configured():
-        return
-    last_scan = get_setting(_jellyfin_scan_key)
-    if last_scan:
-        try:
-            parsed = datetime.fromisoformat(last_scan.replace("Z", "+00:00"))
-            if (datetime.now(timezone.utc) - parsed).total_seconds() < JELLYFIN_SCAN_COOLDOWN_SECONDS:
-                return
-        except ValueError:
-            pass
-    previous = await asyncio.to_thread(get_recent_snapshots, snapshot.request_id, 1)
-    if previous:
-        prev_state = previous[0].get("state")
-        if prev_state in {NormalizedState.available.value, NormalizedState.completed.value}:
-            return
-    try:
-        await client.refresh_library()
-    except Exception as exc:
-        logger.warning("Jellyfin library refresh failed: %s", exc)
-        return
-    set_setting(_jellyfin_scan_key, datetime.now(timezone.utc).isoformat())
-    logger.info("Jellyfin library refresh triggered: request_id=%s", snapshot.request_id)
-
-
 def _queue_records(queue: Any) -> List[Dict[str, Any]]:
     if isinstance(queue, dict):
         records = queue.get("records")
@@ -226,21 +185,7 @@ async def build_snapshot(request_id: str) -> Snapshot:
             logging.getLogger(__name__).debug(
                 "snapshot cache miss: request_id=%s mode=%s", request_id, mode
             )
-        if cached_request is not None:
-            cache_meta = get_request_cache_by_id(int(request_id))
-            cached_title = cache_meta.get("title") if cache_meta else None
-            if cached_title and isinstance(cached_request, dict):
-                media = cached_request.get("media")
-                if not isinstance(media, dict):
-                    media = {}
-                    cached_request["media"] = media
-                if not media.get("title") and not media.get("name"):
-                    media["title"] = cached_title
-                    media["name"] = cached_title
-                if not cached_request.get("title") and not cached_request.get("name"):
-                    cached_request["title"] = cached_title
 
-    allow_remote = mode == "always_js" and jellyseerr.configured()
     if not jellyseerr.configured() and not cached_request:
         timeline.append(TimelineHop(service="Jellyseerr", status="not_configured"))
         timeline.append(TimelineHop(service="Sonarr/Radarr", status="not_configured"))
@@ -248,15 +193,9 @@ async def build_snapshot(request_id: str) -> Snapshot:
         timeline.append(TimelineHop(service="qBittorrent", status="not_configured"))
         snapshot.timeline = timeline
         return snapshot
-    if cached_request is None and not allow_remote:
-        timeline.append(TimelineHop(service="Jellyseerr", status="cache_miss"))
-        snapshot.timeline = timeline
-        snapshot.state = NormalizedState.unknown
-        snapshot.state_reason = "Request not found in cache"
-        return snapshot
 
     jelly_request = cached_request
-    if allow_remote and (jelly_request is None or mode == "always_js"):
+    if (jelly_request is None or mode == "always_js") and jellyseerr.configured():
         try:
             jelly_request = await jellyseerr.get_request(request_id)
             logging.getLogger(__name__).debug(
@@ -279,25 +218,17 @@ async def build_snapshot(request_id: str) -> Snapshot:
     jelly_status = jelly_request.get("status", "unknown")
     jelly_status_label = _status_label(jelly_status)
     jelly_type = jelly_request.get("type") or "unknown"
-    media = jelly_request.get("media", {}) if isinstance(jelly_request, dict) else {}
+    snapshot.title = jelly_request.get("media", {}).get("title", "Unknown")
-    if not isinstance(media, dict):
+    snapshot.year = jelly_request.get("media", {}).get("year")
-        media = {}
-    snapshot.title = (
-        media.get("title")
-        or media.get("name")
-        or jelly_request.get("title")
-        or jelly_request.get("name")
-        or "Unknown"
-    )
-    snapshot.year = media.get("year") or jelly_request.get("year")
     snapshot.request_type = RequestType(jelly_type) if jelly_type in {"movie", "tv"} else RequestType.unknown
+    media = jelly_request.get("media", {}) if isinstance(jelly_request, dict) else {}
     poster_path = None
     backdrop_path = None
     if isinstance(media, dict):
         poster_path = media.get("posterPath") or media.get("poster_path")
         backdrop_path = media.get("backdropPath") or media.get("backdrop_path")
 
-    if snapshot.title in {None, "", "Unknown"} and allow_remote:
+    if snapshot.title in {None, "", "Unknown"} and jellyseerr.configured():
         tmdb_id = jelly_request.get("media", {}).get("tmdbId")
         if tmdb_id:
             try:
@@ -450,6 +381,10 @@ async def build_snapshot(request_id: str) -> Snapshot:
 
     if arr_state is None:
         arr_state = "unknown"
+    if arr_state == "missing" and media_status_code in {4}:
+        arr_state = "available"
+    elif arr_state == "missing" and media_status_code in {6}:
+        arr_state = "added"
 
     timeline.append(TimelineHop(service="Sonarr/Radarr", status=arr_state, details=arr_details))
 
@@ -589,7 +524,7 @@ async def build_snapshot(request_id: str) -> Snapshot:
             snapshot.state_reason = "Waiting for download to start in qBittorrent."
     elif arr_state == "missing" and derived_approved:
         snapshot.state = NormalizedState.needs_add
-        snapshot.state_reason = "Approved, but not yet added to Sonarr/Radarr."
+        snapshot.state_reason = "Approved, but not added to the library yet."
     elif arr_state == "searching":
         snapshot.state = NormalizedState.searching
         snapshot.state_reason = "Searching for a matching release."
@@ -613,7 +548,7 @@ async def build_snapshot(request_id: str) -> Snapshot:
         actions.append(
             ActionOption(
                 id="readd_to_arr",
-                label="Push to Sonarr/Radarr",
+                label="Add to the library queue (Sonarr/Radarr)",
                 risk="medium",
             )
         )
@@ -669,6 +604,5 @@ async def build_snapshot(request_id: str) -> Snapshot:
         },
     }
 
-    await _maybe_refresh_jellyfin(snapshot)
     await asyncio.to_thread(save_snapshot, snapshot)
     return snapshot

docker-compose.yml

@@ -3,8 +3,6 @@ services:
     build:
       context: .
       dockerfile: backend/Dockerfile
-      args:
-        BUILD_NUMBER: ${BUILD_NUMBER}
     env_file:
       - ./.env
     ports:

frontend/app/admin/SettingsPage.tsx

@@ -1,8 +1,15 @@
 'use client'
 
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useEffect, useMemo, useState } from 'react'
 import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
+import {
+  authFetch,
+  authFetchOrThrow,
+  ForbiddenError,
+  getApiBase,
+  getToken,
+  UnauthorizedError,
+} from '../lib/auth'
 import AdminShell from '../ui/AdminShell'
 
 type AdminSetting = {
@@ -21,39 +28,35 @@ type ServiceOptions = {
 const SECTION_LABELS: Record<string, string> = {
   jellyseerr: 'Jellyseerr',
   jellyfin: 'Jellyfin',
-  artwork: 'Artwork cache',
+  artwork: 'Artwork',
-  cache: 'Cache Control',
+  cache: 'Cache',
   sonarr: 'Sonarr',
   radarr: 'Radarr',
   prowlarr: 'Prowlarr',
   qbittorrent: 'qBittorrent',
   log: 'Activity log',
-  requests: 'Request sync',
+  requests: 'Request syncing',
-  site: 'Site',
 }
 
-const BOOL_SETTINGS = new Set(['jellyfin_sync_to_arr', 'site_banner_enabled'])
+const BOOL_SETTINGS = new Set(['jellyfin_sync_to_arr'])
-const TEXTAREA_SETTINGS = new Set(['site_banner_message', 'site_changelog'])
-const BANNER_TONES = ['info', 'warning', 'error', 'maintenance']
 
 const SECTION_DESCRIPTIONS: Record<string, string> = {
   jellyseerr: 'Connect the request system where users submit content.',
   jellyfin: 'Control Jellyfin login and availability checks.',
-  artwork: 'Cache posters/backdrops and review artwork coverage.',
+  artwork: 'Configure how posters and artwork are loaded.',
-  cache: 'Manage saved requests cache and refresh behavior.',
+  cache: 'Manage saved request data and offline artwork.',
   sonarr: 'TV automation settings.',
   radarr: 'Movie automation settings.',
   prowlarr: 'Indexer search settings.',
   qbittorrent: 'Downloader connection settings.',
-  requests: 'Control how often requests are refreshed and cleaned up.',
+  requests: 'Sync and refresh cadence for requests.',
   log: 'Activity log for troubleshooting.',
-  site: 'Sitewide banner, version, and changelog details.',
 }
 
 const SETTINGS_SECTION_MAP: Record<string, string | null> = {
   jellyseerr: 'jellyseerr',
   jellyfin: 'jellyfin',
-  artwork: null,
+  artwork: 'artwork',
   sonarr: 'sonarr',
   radarr: 'radarr',
   prowlarr: 'prowlarr',
@@ -62,7 +65,6 @@ const SETTINGS_SECTION_MAP: Record<string, string | null> = {
   cache: null,
   logs: 'log',
   maintenance: null,
-  site: 'site',
 }
 
 const labelFromKey = (key: string) =>
@@ -73,34 +75,16 @@ const labelFromKey = (key: string) =>
     .replace('quality profile id', 'Quality profile ID')
     .replace('root folder', 'Root folder')
     .replace('qbittorrent', 'qBittorrent')
-    .replace('requests sync ttl minutes', 'Saved request refresh TTL (minutes)')
+    .replace('requests sync ttl minutes', 'Refresh saved requests if older than (minutes)')
-    .replace('requests poll interval seconds', 'Full refresh check interval (seconds)')
+    .replace('requests poll interval seconds', 'Background refresh check (seconds)')
-    .replace('requests delta sync interval minutes', 'Delta sync interval (minutes)')
+    .replace('requests delta sync interval minutes', 'Check for new or updated requests every (minutes)')
-    .replace('requests full sync time', 'Daily full refresh time (24h)')
+    .replace('requests full sync time', 'Full refresh time (24h)')
-    .replace('requests cleanup time', 'Daily history cleanup time (24h)')
+    .replace('requests cleanup time', 'Clean up old history time (24h)')
-    .replace('requests cleanup days', 'History retention window (days)')
+    .replace('requests cleanup days', 'Remove history older than (days)')
-    .replace('requests data source', 'Request source (cache vs Jellyseerr)')
+    .replace('requests data source', 'Where requests are loaded from')
     .replace('jellyfin public url', 'Jellyfin public URL')
     .replace('jellyfin sync to arr', 'Sync Jellyfin to Sonarr/Radarr')
     .replace('artwork cache mode', 'Artwork cache mode')
-    .replace('site build number', 'Build number')
-    .replace('site banner enabled', 'Sitewide banner enabled')
-    .replace('site banner message', 'Sitewide banner message')
-    .replace('site banner tone', 'Sitewide banner tone')
-    .replace('site changelog', 'Changelog text')
-
-const formatBytes = (value?: number | null) => {
-  if (!value || value <= 0) return '0 B'
-  const units = ['B', 'KB', 'MB', 'GB', 'TB']
-  let size = value
-  let unitIndex = 0
-  while (size >= 1024 && unitIndex < units.length - 1) {
-    size /= 1024
-    unitIndex += 1
-  }
-  const decimals = unitIndex === 0 || size >= 10 ? 0 : 1
-  return `${size.toFixed(decimals)} ${units[unitIndex]}`
-}
 
 type SettingsPageProps = {
   section: string
@@ -125,27 +109,15 @@ export default function SettingsPage({ section }: SettingsPageProps) {
   const [cacheRows, setCacheRows] = useState<any[]>([])
   const [cacheCount, setCacheCount] = useState(50)
   const [cacheStatus, setCacheStatus] = useState<string | null>(null)
-  const [cacheLoading, setCacheLoading] = useState(false)
   const [requestsSync, setRequestsSync] = useState<any | null>(null)
   const [artworkPrefetch, setArtworkPrefetch] = useState<any | null>(null)
-  const [artworkSummary, setArtworkSummary] = useState<any | null>(null)
-  const [artworkSummaryStatus, setArtworkSummaryStatus] = useState<string | null>(null)
   const [maintenanceStatus, setMaintenanceStatus] = useState<string | null>(null)
   const [maintenanceBusy, setMaintenanceBusy] = useState(false)
 
-  const loadSettings = useCallback(async () => {
+  const loadSettings = async () => {
     const baseUrl = getApiBase()
-    const response = await authFetch(`${baseUrl}/admin/settings`)
+    const response = await authFetchOrThrow(`${baseUrl}/admin/settings`)
     if (!response.ok) {
-      if (response.status === 401) {
-        clearToken()
-        router.push('/login')
-        return
-      }
-      if (response.status === 403) {
-        router.push('/')
-        return
-      }
       throw new Error('Failed to load settings')
     }
     const data = await response.json()
@@ -165,9 +137,9 @@ export default function SettingsPage({ section }: SettingsPageProps) {
     }
     setFormValues(initialValues)
     setStatus(null)
-  }, [router])
+  }
 
-  const loadArtworkPrefetchStatus = useCallback(async () => {
+  const loadArtworkPrefetchStatus = async () => {
     try {
       const baseUrl = getApiBase()
       const response = await authFetch(`${baseUrl}/admin/requests/artwork/status`)
@@ -179,30 +151,10 @@ export default function SettingsPage({ section }: SettingsPageProps) {
     } catch (err) {
       console.error(err)
     }
-  }, [])
+  }
 
-  const loadArtworkSummary = useCallback(async () => {
-    setArtworkSummaryStatus(null)
-    try {
-      const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/admin/requests/artwork/summary`)
-      if (!response.ok) {
-        const text = await response.text()
-        throw new Error(text || 'Artwork summary fetch failed')
-      }
-      const data = await response.json()
-      setArtworkSummary(data?.summary ?? null)
-    } catch (err) {
-      console.error(err)
-      const message =
-        err instanceof Error && err.message
-          ? err.message.replace(/^\\{\"detail\":\"|\"\\}$/g, '')
-          : 'Could not load artwork stats.'
-      setArtworkSummaryStatus(message)
-    }
-  }, [])
 
-  const loadOptions = useCallback(async (service: 'sonarr' | 'radarr') => {
+  const loadOptions = async (service: 'sonarr' | 'radarr') => {
     try {
       const baseUrl = getApiBase()
       const response = await authFetch(`${baseUrl}/admin/${service}/options`)
@@ -231,7 +183,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
         setRadarrError('Could not load Radarr options.')
       }
     }
-  }, [])
+  }
 
   useEffect(() => {
     const load = async () => {
@@ -241,11 +193,18 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       }
       try {
         await loadSettings()
-        if (section === 'cache' || section === 'artwork') {
+        if (section === 'artwork') {
           await loadArtworkPrefetchStatus()
-          await loadArtworkSummary()
         }
       } catch (err) {
+        if (err instanceof UnauthorizedError) {
+          router.push('/login')
+          return
+        }
+        if (err instanceof ForbiddenError) {
+          router.push('/')
+          return
+        }
         console.error(err)
         setStatus('Could not load admin settings.')
       } finally {
@@ -260,7 +219,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
     if (section === 'radarr') {
       void loadOptions('radarr')
     }
-  }, [loadArtworkPrefetchStatus, loadArtworkSummary, loadOptions, loadSettings, router, section])
+  }, [router, section])
 
   const groupedSettings = useMemo(() => {
     const groups: Record<string, AdminSetting[]> = {}
@@ -275,51 +234,28 @@ export default function SettingsPage({ section }: SettingsPageProps) {
   const settingsSection = SETTINGS_SECTION_MAP[section] ?? null
   const visibleSections = settingsSection ? [settingsSection] : []
   const isCacheSection = section === 'cache'
-  const cacheSettingKeys = new Set(['requests_sync_ttl_minutes', 'requests_data_source'])
+  const cacheSettingKeys = new Set([
-  const artworkSettingKeys = new Set(['artwork_cache_mode'])
+    'requests_sync_ttl_minutes',
-  const hiddenSettingKeys = new Set([...cacheSettingKeys, ...artworkSettingKeys])
+    'requests_data_source',
-  const requestSettingOrder = [
+    'artwork_cache_mode',
-    'requests_poll_interval_seconds',
+  ])
-    'requests_delta_sync_interval_minutes',
-    'requests_full_sync_time',
-    'requests_cleanup_time',
-    'requests_cleanup_days',
-  ]
-  const sortByOrder = (items: AdminSetting[], order: string[]) => {
-    const position = new Map(order.map((key, index) => [key, index]))
-    return [...items].sort((a, b) => {
-      const aIndex = position.get(a.key) ?? Number.POSITIVE_INFINITY
-      const bIndex = position.get(b.key) ?? Number.POSITIVE_INFINITY
-      if (aIndex !== bIndex) return aIndex - bIndex
-      return a.key.localeCompare(b.key)
-    })
-  }
   const cacheSettings = settings.filter((setting) => cacheSettingKeys.has(setting.key))
-  const artworkSettings = settings.filter((setting) => artworkSettingKeys.has(setting.key))
   const settingsSections = isCacheSection
-    ? [
+    ? [{ key: 'cache', title: 'Cache settings', items: cacheSettings }]
-        { key: 'cache', title: 'Cache control', items: cacheSettings },
-        { key: 'artwork', title: 'Artwork cache', items: artworkSettings },
-      ]
     : visibleSections.map((sectionKey) => ({
         key: sectionKey,
         title: SECTION_LABELS[sectionKey] ?? sectionKey,
-        items: (() => {
+        items:
-          const sectionItems = groupedSettings[sectionKey] ?? []
+          sectionKey === 'requests' || sectionKey === 'artwork'
-          const filtered =
+            ? (groupedSettings[sectionKey] ?? []).filter(
-            sectionKey === 'requests' || sectionKey === 'artwork'
+                (setting) => !cacheSettingKeys.has(setting.key)
-              ? sectionItems.filter((setting) => !hiddenSettingKeys.has(setting.key))
+              )
-              : sectionItems
+            : groupedSettings[sectionKey] ?? [],
-          if (sectionKey === 'requests') {
-            return sortByOrder(filtered, requestSettingOrder)
-          }
-          return filtered
-        })(),
       }))
   const showLogs = section === 'logs'
   const showMaintenance = section === 'maintenance'
   const showRequestsExtras = section === 'requests'
-  const showArtworkExtras = section === 'cache'
+  const showArtworkExtras = section === 'artwork'
   const showCacheExtras = section === 'cache'
   const shouldRenderSection = (sectionGroup: { key: string; items?: AdminSetting[] }) => {
     if (sectionGroup.items && sectionGroup.items.length > 0) return true
@@ -341,34 +277,24 @@ export default function SettingsPage({ section }: SettingsPageProps) {
     sonarr_api_key: 'API key for Sonarr.',
     sonarr_quality_profile_id: 'Quality profile used when adding TV shows.',
     sonarr_root_folder: 'Root folder where Sonarr stores TV shows.',
-    sonarr_qbittorrent_category: 'qBittorrent category for manual Sonarr downloads.',
     radarr_base_url: 'Radarr server URL for movies.',
     radarr_api_key: 'API key for Radarr.',
     radarr_quality_profile_id: 'Quality profile used when adding movies.',
     radarr_root_folder: 'Root folder where Radarr stores movies.',
-    radarr_qbittorrent_category: 'qBittorrent category for manual Radarr downloads.',
     prowlarr_base_url: 'Prowlarr server URL for indexer searches.',
     prowlarr_api_key: 'API key for Prowlarr.',
     qbittorrent_base_url: 'qBittorrent server URL for download status.',
     qbittorrent_username: 'qBittorrent login username.',
     qbittorrent_password: 'qBittorrent login password.',
     requests_sync_ttl_minutes: 'How long saved requests stay fresh before a refresh is needed.',
-    requests_poll_interval_seconds:
+    requests_poll_interval_seconds: 'How often the background checker runs.',
-      'How often Magent checks if a full refresh should run.',
+    requests_delta_sync_interval_minutes: 'How often we check for new or updated requests.',
-    requests_delta_sync_interval_minutes:
+    requests_full_sync_time: 'Daily time to refresh the full request list.',
-      'How often we poll for new or updated requests.',
+    requests_cleanup_time: 'Daily time to trim old history.',
-    requests_full_sync_time: 'Daily time to rebuild the full request cache.',
-    requests_cleanup_time: 'Daily time to trim old request history.',
     requests_cleanup_days: 'History older than this is removed during cleanup.',
-    requests_data_source:
+    requests_data_source: 'Pick where Magent should read requests from.',
-      'Pick where Magent should read requests from. Cache-only avoids Jellyseerr lookups on reads.',
     log_level: 'How much detail is written to the activity log.',
     log_file: 'Where the activity log is stored.',
-    site_build_number: 'Build number shown in the account menu (auto-set from releases).',
-    site_banner_enabled: 'Enable a sitewide banner for announcements.',
-    site_banner_message: 'Short banner message for maintenance or updates.',
-    site_banner_tone: 'Visual tone for the banner.',
-    site_changelog: 'One update per line for the public changelog.',
   }
 
   const buildSelectOptions = (
@@ -526,31 +452,6 @@ export default function SettingsPage({ section }: SettingsPageProps) {
     }
   }
 
-  const prefetchArtworkMissing = async () => {
-    setArtworkPrefetchStatus(null)
-    try {
-      const baseUrl = getApiBase()
-      const response = await authFetch(
-        `${baseUrl}/admin/requests/artwork/prefetch?only_missing=1`,
-        { method: 'POST' }
-      )
-      if (!response.ok) {
-        const text = await response.text()
-        throw new Error(text || 'Missing artwork prefetch failed')
-      }
-      const data = await response.json()
-      setArtworkPrefetch(data?.prefetch ?? null)
-      setArtworkPrefetchStatus('Missing artwork caching started.')
-    } catch (err) {
-      console.error(err)
-      const message =
-        err instanceof Error && err.message
-          ? err.message.replace(/^\\{\"detail\":\"|\"\\}$/g, '')
-          : 'Could not cache missing artwork.'
-      setArtworkPrefetchStatus(message)
-    }
-  }
-
   useEffect(() => {
     if (!artworkPrefetch || artworkPrefetch.status !== 'running') {
       return
@@ -568,7 +469,6 @@ export default function SettingsPage({ section }: SettingsPageProps) {
         setArtworkPrefetch(data?.prefetch ?? null)
         if (data?.prefetch?.status && data.prefetch.status !== 'running') {
           setArtworkPrefetchStatus(data.prefetch.message || 'Artwork caching complete.')
-          void loadArtworkSummary()
         }
       } catch (err) {
         console.error(err)
@@ -578,7 +478,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       active = false
       clearInterval(timer)
     }
-  }, [artworkPrefetch, loadArtworkSummary])
+  }, [artworkPrefetch?.status])
 
   useEffect(() => {
     if (!artworkPrefetch || artworkPrefetch.status === 'running') {
@@ -588,7 +488,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       setArtworkPrefetch(null)
     }, 5000)
     return () => clearTimeout(timer)
-  }, [artworkPrefetch])
+  }, [artworkPrefetch?.status])
 
   useEffect(() => {
     if (!requestsSync || requestsSync.status !== 'running') {
@@ -616,7 +516,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       active = false
       clearInterval(timer)
     }
-  }, [requestsSync])
+  }, [requestsSync?.status])
 
   useEffect(() => {
     if (!requestsSync || requestsSync.status === 'running') {
@@ -626,9 +526,9 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       setRequestsSync(null)
     }, 5000)
     return () => clearTimeout(timer)
-  }, [requestsSync])
+  }, [requestsSync?.status])
 
-  const loadLogs = useCallback(async () => {
+  const loadLogs = async () => {
     setLogsStatus(null)
     try {
       const baseUrl = getApiBase()
@@ -653,7 +553,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
           : 'Could not load logs.'
       setLogsStatus(message)
     }
-  }, [logsCount])
+  }
 
   useEffect(() => {
     if (!showLogs) {
@@ -664,11 +564,10 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       void loadLogs()
     }, 5000)
     return () => clearInterval(timer)
-  }, [loadLogs, showLogs])
+  }, [logsCount, showLogs])
 
   const loadCache = async () => {
     setCacheStatus(null)
-    setCacheLoading(true)
     try {
       const baseUrl = getApiBase()
       const response = await authFetch(
@@ -691,8 +590,6 @@ export default function SettingsPage({ section }: SettingsPageProps) {
           ? err.message.replace(/^\\{\"detail\":\"|\"\\}$/g, '')
           : 'Could not load cache.'
       setCacheStatus(message)
-    } finally {
-      setCacheLoading(false)
     }
   }
 
@@ -807,9 +704,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
           .map((sectionGroup) => (
           <section key={sectionGroup.key} className="admin-section">
             <div className="section-header">
-              <h2>
+              <h2>{sectionGroup.title}</h2>
-                {sectionGroup.key === 'requests' ? 'Request sync controls' : sectionGroup.title}
-              </h2>
               {sectionGroup.key === 'sonarr' && (
                 <button type="button" onClick={() => loadOptions('sonarr')}>
                   Refresh Sonarr options
@@ -825,38 +720,24 @@ export default function SettingsPage({ section }: SettingsPageProps) {
                   Import Jellyfin users
                 </button>
               )}
-              {showArtworkExtras && sectionGroup.key === 'artwork' ? (
+              {(showArtworkExtras && sectionGroup.key === 'artwork') ||
-                <div className="sync-actions">
+              (showCacheExtras && sectionGroup.key === 'cache') ? (
-                  <button type="button" onClick={prefetchArtwork}>
+                <button type="button" onClick={prefetchArtwork}>
-                    Cache all artwork now
+                  Cache all artwork now
-                  </button>
+                </button>
-                  <button
-                    type="button"
-                    className="ghost-button"
-                    onClick={prefetchArtworkMissing}
-                  >
-                    Sync only missing artwork
-                  </button>
-                </div>
               ) : null}
               {showRequestsExtras && sectionGroup.key === 'requests' && (
-                <div className="sync-actions-block">
+                <div className="sync-actions">
-                  <div className="sync-actions">
+                  <button type="button" onClick={syncRequests}>
-                    <button type="button" onClick={syncRequests}>
+                    Full refresh
-                      Run full refresh (rebuild cache)
+                  </button>
-                    </button>
+                  <button type="button" className="ghost-button" onClick={syncRequestsDelta}>
-                    <button type="button" className="ghost-button" onClick={syncRequestsDelta}>
+                    Quick refresh (new changes)
-                      Run delta sync (recent changes)
+                  </button>
-                    </button>
-                  </div>
-                  <div className="meta sync-note">
-                    Full refresh rebuilds the entire cache. Delta sync only checks new or updated
-                    requests.
-                  </div>
                 </div>
               )}
             </div>
-            {SECTION_DESCRIPTIONS[sectionGroup.key] && !settingsSection && (
+            {SECTION_DESCRIPTIONS[sectionGroup.key] && (
               <p className="section-subtitle">{SECTION_DESCRIPTIONS[sectionGroup.key]}</p>
             )}
             {sectionGroup.key === 'sonarr' && sonarrError && (
@@ -868,48 +749,17 @@ export default function SettingsPage({ section }: SettingsPageProps) {
             {sectionGroup.key === 'jellyfin' && jellyfinSyncStatus && (
               <div className="status-banner">{jellyfinSyncStatus}</div>
             )}
-            {showArtworkExtras && sectionGroup.key === 'artwork' && artworkPrefetchStatus && (
+            {((showArtworkExtras && sectionGroup.key === 'artwork') ||
+              (showCacheExtras && sectionGroup.key === 'cache')) &&
+              artworkPrefetchStatus && (
               <div className="status-banner">{artworkPrefetchStatus}</div>
             )}
-            {showArtworkExtras && sectionGroup.key === 'artwork' && artworkSummaryStatus && (
-              <div className="status-banner">{artworkSummaryStatus}</div>
-            )}
-            {showArtworkExtras && sectionGroup.key === 'artwork' && (
-              <div className="summary">
-                <div className="summary-card">
-                  <strong>Missing artwork</strong>
-                  <p>{artworkSummary?.missing_artwork ?? '--'}</p>
-                  <div className="meta">Requests missing poster/backdrop or cache files.</div>
-                </div>
-                <div className="summary-card">
-                  <strong>Artwork cache size</strong>
-                  <p>{formatBytes(artworkSummary?.cache_bytes)}</p>
-                  <div className="meta">
-                    {artworkSummary?.cache_files ?? '--'} cached files
-                  </div>
-                </div>
-                <div className="summary-card">
-                  <strong>Total requests</strong>
-                  <p>{artworkSummary?.total_requests ?? '--'}</p>
-                  <div className="meta">Requests currently tracked in cache.</div>
-                </div>
-                <div className="summary-card">
-                  <strong>Cache mode</strong>
-                  <p>{artworkSummary?.cache_mode ?? '--'}</p>
-                  <div className="meta">Artwork setting applied to posters/backdrops.</div>
-                </div>
-              </div>
-            )}
             {showRequestsExtras && sectionGroup.key === 'requests' && requestsSyncStatus && (
               <div className="status-banner">{requestsSyncStatus}</div>
             )}
-            {showRequestsExtras && sectionGroup.key === 'requests' && (
+            {((showArtworkExtras && sectionGroup.key === 'artwork') ||
-              <div className="status-banner">
+              (showCacheExtras && sectionGroup.key === 'cache')) &&
-                Full refresh checks only decide when to run a full refresh. The delta sync interval
+              artworkPrefetch && (
-                polls for new or updated requests.
-              </div>
-            )}
-            {showArtworkExtras && sectionGroup.key === 'artwork' && artworkPrefetch && (
               <div className="sync-progress">
                 <div className="sync-meta">
                   <span>Status: {artworkPrefetch.status}</span>
@@ -1163,34 +1013,6 @@ export default function SettingsPage({ section }: SettingsPageProps) {
                     </label>
                   )
                 }
-                if (setting.key === 'site_banner_tone') {
-                  return (
-                    <label key={setting.key} data-helper={helperText || undefined}>
-                      <span className="label-row">
-                        <span>{labelFromKey(setting.key)}</span>
-                        <span className="meta">
-                          {setting.isSet ? `Source: ${setting.source}` : 'Not set'}
-                        </span>
-                      </span>
-                      <select
-                        name={setting.key}
-                        value={value || 'info'}
-                        onChange={(event) =>
-                          setFormValues((current) => ({
-                            ...current,
-                            [setting.key]: event.target.value,
-                          }))
-                        }
-                      >
-                        {BANNER_TONES.map((tone) => (
-                          <option key={tone} value={tone}>
-                            {tone.charAt(0).toUpperCase() + tone.slice(1)}
-                          </option>
-                        ))}
-                      </select>
-                    </label>
-                  )
-                }
                 if (
                   setting.key === 'requests_full_sync_time' ||
                   setting.key === 'requests_cleanup_time'
@@ -1264,42 +1086,11 @@ export default function SettingsPage({ section }: SettingsPageProps) {
                         }
                       >
                         <option value="always_js">Always use Jellyseerr (slower)</option>
-                        <option value="prefer_cache">
+                        <option value="prefer_cache">Use saved requests first (faster)</option>
-                          Use saved requests only (fastest)
-                        </option>
                       </select>
                     </label>
                   )
                 }
-                if (TEXTAREA_SETTINGS.has(setting.key)) {
-                  return (
-                    <label key={setting.key} data-helper={helperText || undefined}>
-                      <span className="label-row">
-                        <span>{labelFromKey(setting.key)}</span>
-                        <span className="meta">
-                          {setting.isSet ? `Source: ${setting.source}` : 'Not set'}
-                          {setting.sensitive && setting.isSet ? '  stored' : ''}
-                        </span>
-                      </span>
-                      <textarea
-                        name={setting.key}
-                        rows={setting.key === 'site_changelog' ? 6 : 3}
-                        placeholder={
-                          setting.key === 'site_changelog'
-                            ? 'One update per line.'
-                            : ''
-                        }
-                        value={value}
-                        onChange={(event) =>
-                          setFormValues((current) => ({
-                            ...current,
-                            [setting.key]: event.target.value,
-                          }))
-                        }
-                      />
-                    </label>
-                  )
-                }
                 return (
                   <label key={setting.key} data-helper={helperText || undefined}>
                     <span className="label-row">
@@ -1336,7 +1127,7 @@ export default function SettingsPage({ section }: SettingsPageProps) {
       </form>
       ) : (
       <div className="status-banner">
-        No settings to show here yet. Try the Cache Control page for artwork and saved-request controls.
+        No settings to show here yet. Try the Cache page for artwork and saved-request controls.
       </div>
       )}
       {showLogs && (
@@ -1382,15 +1173,8 @@ export default function SettingsPage({ section }: SettingsPageProps) {
                 <option value={200}>200</option>
               </select>
             </label>
-            <button type="button" onClick={loadCache} disabled={cacheLoading}>
+            <button type="button" onClick={loadCache}>
-              {cacheLoading ? (
+              Load saved requests
-                <>
-                  <span className="spinner button-spinner" aria-hidden="true" />
-                  Loading saved requests
-                </>
-              ) : (
-                'Load saved requests'
-              )}
             </button>
           </div>
         </div>

frontend/app/admin/[section]/page.tsx

@@ -13,7 +13,6 @@ const ALLOWED_SECTIONS = new Set([
   'cache',
   'logs',
   'maintenance',
-  'site',
 ])
 
 type PageProps = {

frontend/app/changelog/page.tsx

@@ -1,85 +0,0 @@
-'use client'
-
-import { useEffect, useMemo, useState } from 'react'
-import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
-
-type SiteInfo = {
-  changelog?: string
-}
-
-const parseChangelog = (raw: string) =>
-  raw
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-
-export default function ChangelogPage() {
-  const router = useRouter()
-  const [entries, setEntries] = useState<string[]>([])
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    const token = getToken()
-    if (!token) {
-      router.push('/login')
-      return
-    }
-    let active = true
-    const load = async () => {
-      try {
-        const baseUrl = getApiBase()
-        const response = await authFetch(`${baseUrl}/site/info`)
-        if (!response.ok) {
-          if (response.status === 401) {
-            clearToken()
-            router.push('/login')
-            return
-          }
-          throw new Error('Failed to load changelog')
-        }
-        const data: SiteInfo = await response.json()
-        if (!active) return
-        setEntries(parseChangelog(data?.changelog ?? ''))
-      } catch (err) {
-        console.error(err)
-        if (!active) return
-        setEntries([])
-      } finally {
-        if (active) setLoading(false)
-      }
-    }
-    void load()
-    return () => {
-      active = false
-    }
-  }, [router])
-
-  const content = useMemo(() => {
-    if (loading) {
-      return <div className="loading-text">Loading changelog...</div>
-    }
-    if (entries.length === 0) {
-      return <div className="meta">No updates posted yet.</div>
-    }
-    return (
-      <ul className="changelog-list">
-        {entries.map((entry, index) => (
-          <li key={`${entry}-${index}`}>{entry}</li>
-        ))}
-      </ul>
-    )
-  }, [entries, loading])
-
-  return (
-    <div className="page">
-      <section className="card changelog-card">
-        <div className="changelog-header">
-          <h1>Changelog</h1>
-          <p className="lede">Latest updates and release notes.</p>
-        </div>
-        {content}
-      </section>
-    </div>
-  )
-}

frontend/app/feedback/page.tsx

@@ -2,7 +2,7 @@
 
 import { useEffect, useState } from 'react'
 import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
+import { authFetchOrThrow, getApiBase, getToken, UnauthorizedError } from '../lib/auth'
 
 type Profile = {
   username?: string
@@ -24,15 +24,17 @@ export default function FeedbackPage() {
     const load = async () => {
       try {
         const baseUrl = getApiBase()
-        const response = await authFetch(`${baseUrl}/auth/me`)
+        const response = await authFetchOrThrow(`${baseUrl}/auth/me`)
         if (!response.ok) {
-          clearToken()
+          throw new Error('Could not load profile.')
-          router.push('/login')
-          return
         }
         const data = await response.json()
         setProfile({ username: data?.username })
       } catch (error) {
+        if (error instanceof UnauthorizedError) {
+          router.push('/login')
+          return
+        }
         console.error(error)
       }
     }
@@ -49,7 +51,7 @@ export default function FeedbackPage() {
     setSubmitting(true)
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/feedback`, {
+      const response = await authFetchOrThrow(`${baseUrl}/feedback`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -58,17 +60,16 @@ export default function FeedbackPage() {
         }),
       })
       if (!response.ok) {
-        if (response.status === 401) {
-          clearToken()
-          router.push('/login')
-          return
-        }
         const text = await response.text()
         throw new Error(text || `Request failed: ${response.status}`)
       }
       setMessage('')
       setStatus('Thanks! Your message has been sent.')
     } catch (error) {
+      if (error instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
       console.error(error)
       setStatus('That did not send. Please try again.')
     } finally {

frontend/app/globals.css

@@ -175,35 +175,30 @@ body {
   margin-right: auto;
 }
 
+.signed-in {
+  font-size: 12px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--ink-muted);
+  padding: 6px 10px;
+  border-radius: 999px;
+  border: 1px dashed var(--border);
+  background: transparent;
+  cursor: pointer;
+}
+
 .signed-in-menu {
   position: relative;
   display: inline-flex;
   align-items: center;
 }
 
-.avatar-button {
-  width: 44px;
-  height: 44px;
-  border-radius: 50%;
-  border: 1px solid rgba(255, 255, 255, 0.12);
-  background: linear-gradient(130deg, rgba(28, 107, 255, 0.35), rgba(17, 214, 198, 0.25));
-  color: var(--ink);
-  font-weight: 700;
-  letter-spacing: 0.04em;
-  text-transform: uppercase;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  box-shadow: 0 10px 20px rgba(28, 107, 255, 0.25);
-  cursor: pointer;
-}
-
 .signed-in-dropdown {
   position: absolute;
   top: calc(100% + 8px);
   right: 0;
-  width: min(260px, 90vw);
+  min-width: 180px;
-  background: rgba(14, 20, 32, 0.96);
+  background: rgba(14, 20, 32, 0.95);
   border: 1px solid var(--border);
   border-radius: 12px;
   padding: 8px;
@@ -211,50 +206,17 @@ body {
   z-index: 20;
 }
 
-.signed-in-header {
+.signed-in-dropdown a {
-  font-size: 11px;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-  color: var(--ink-muted);
-  padding: 8px 10px 6px;
-  border-bottom: 1px solid rgba(255, 255, 255, 0.08);
-}
-
-.signed-in-actions {
-  display: grid;
-  gap: 6px;
-  padding: 8px 4px 4px;
-}
-
-.signed-in-actions a,
-.signed-in-signout {
   display: block;
   padding: 8px 12px;
   border-radius: 10px;
   color: var(--ink);
   text-decoration: none;
-  text-align: left;
+  text-align: center;
-  background: rgba(255, 255, 255, 0.05);
-  border: 1px solid rgba(255, 255, 255, 0.08);
 }
 
-.signed-in-signout {
+.signed-in-dropdown a:hover {
-  cursor: pointer;
+  background: rgba(255, 255, 255, 0.08);
-  font: inherit;
-}
-
-.signed-in-actions a:hover,
-.signed-in-signout:hover {
-  background: rgba(255, 255, 255, 0.12);
-}
-
-.signed-in-build {
-  margin-top: 6px;
-  padding: 6px 10px 8px;
-  font-size: 11px;
-  color: var(--ink-muted);
-  text-align: left;
-  letter-spacing: 0.04em;
 }
 
 .theme-toggle {
@@ -559,73 +521,6 @@ button span {
   margin-top: 4px;
 }
 
-.profile-grid {
-  display: grid;
-  gap: 20px;
-}
-
-.profile-section {
-  display: grid;
-  gap: 12px;
-}
-
-.stat-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
-  gap: 12px;
-}
-
-.stat-card {
-  padding: 14px;
-  border-radius: 16px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.05);
-  display: grid;
-  gap: 6px;
-}
-
-.stat-label {
-  font-size: 11px;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-  color: var(--ink-muted);
-}
-
-.stat-value {
-  font-size: 20px;
-  font-weight: 700;
-}
-
-.stat-value--small {
-  font-size: 14px;
-  font-weight: 600;
-}
-
-.connection-list {
-  display: grid;
-  gap: 10px;
-}
-
-.connection-item {
-  display: flex;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 12px 14px;
-  border-radius: 14px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.04);
-}
-
-.connection-label {
-  font-weight: 600;
-}
-
-.connection-count {
-  font-size: 12px;
-  color: var(--ink-muted);
-  white-space: nowrap;
-}
-
 .state {
   display: grid;
   gap: 6px;
@@ -752,28 +647,12 @@ button span {
 }
 
 .user-card {
-  display: grid;
+  display: flex;
-  grid-template-columns: 1fr auto;
+  justify-content: space-between;
-  align-items: start;
+  align-items: center;
   gap: 16px;
 }
 
-.user-card strong {
-  display: block;
-  font-size: 16px;
-  margin-bottom: 6px;
-}
-
-.user-meta {
-  display: grid;
-  gap: 6px;
-  font-size: 13px;
-}
-
-.user-meta .meta {
-  display: block;
-}
-
 .user-actions {
   display: grid;
   gap: 8px;
@@ -1047,17 +926,6 @@ button span {
   flex-wrap: wrap;
 }
 
-.sync-actions-block {
-  display: grid;
-  gap: 6px;
-  justify-items: end;
-  text-align: right;
-}
-
-.sync-note {
-  margin-top: 0;
-}
-
 .section-header button {
   background: rgba(255, 255, 255, 0.08);
   color: var(--ink);
@@ -1100,49 +968,6 @@ button span {
   border: 1px solid var(--border);
 }
 
-.site-banner {
-  padding: 12px 16px;
-  border-radius: 12px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.08);
-  color: var(--ink);
-  font-size: 14px;
-}
-
-.site-banner--info {
-  background: rgba(59, 130, 246, 0.18);
-  border-color: rgba(59, 130, 246, 0.4);
-}
-
-.site-banner--warning {
-  background: rgba(255, 200, 87, 0.22);
-  border-color: rgba(255, 200, 87, 0.5);
-}
-
-.site-banner--error {
-  background: rgba(255, 59, 48, 0.2);
-  border-color: rgba(255, 59, 48, 0.4);
-}
-
-.site-banner--maintenance {
-  background: rgba(255, 107, 43, 0.18);
-  border-color: rgba(255, 107, 43, 0.4);
-}
-
-.site-version {
-  position: fixed;
-  left: 16px;
-  bottom: 12px;
-  font-size: 12px;
-  letter-spacing: 0.04em;
-  color: var(--ink-muted);
-  padding: 6px 10px;
-  border-radius: 999px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.08);
-  z-index: 30;
-}
-
 .recent-header {
   display: flex;
   justify-content: space-between;
@@ -1326,17 +1151,6 @@ button span {
 
 .progress-indeterminate .progress-fill {
   position: absolute;
-  width: 100%;
-  left: 0;
-  top: 0;
-  background: linear-gradient(
-    90deg,
-    rgba(255, 255, 255, 0),
-    var(--accent-2),
-    var(--accent-3),
-    rgba(255, 255, 255, 0)
-  );
-  background-size: 200% 100%;
   animation: progress-indeterminate 1.6s ease-in-out infinite;
 }
 
@@ -1415,24 +1229,6 @@ button span {
   font-size: 13px;
 }
 
-.system-meta {
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-}
-
-.system-test-message {
-  font-size: 11px;
-  color: var(--ink-muted);
-}
-
-.system-actions {
-  margin-left: auto;
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
 .system-dot {
   width: 10px;
   height: 10px;
@@ -1462,28 +1258,10 @@ button span {
 }
 
 .system-state {
+  margin-left: auto;
   color: var(--ink-muted);
 }
 
-.system-test {
-  padding: 4px 10px;
-  border-radius: 999px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.08);
-  color: var(--ink-muted);
-  font-size: 11px;
-  letter-spacing: 0.02em;
-}
-
-.system-test:hover:not(:disabled) {
-  background: rgba(255, 255, 255, 0.16);
-}
-
-.system-test:disabled {
-  opacity: 0.6;
-  cursor: not-allowed;
-}
-
 .pipeline-map {
   border-radius: 16px;
   border: 1px solid var(--border);
@@ -1556,10 +1334,13 @@ button span {
 
 @keyframes progress-indeterminate {
   0% {
-    background-position: 200% 0;
+    transform: translateX(-50%);
+  }
+  50% {
+    transform: translateX(120%);
   }
   100% {
-    background-position: -200% 0;
+    transform: translateX(-50%);
   }
 }
 
@@ -1575,83 +1356,19 @@ button span {
 }
 
 @media (max-width: 720px) {
-  .page {
-    padding: 28px 18px 60px;
-    gap: 24px;
-  }
-
   .header {
     grid-template-columns: 1fr;
     grid-template-rows: auto auto auto;
     align-items: flex-start;
   }
 
-  .header-left {
-    width: 100%;
-  }
-
-  .brand-link {
-    width: 100%;
-    gap: 12px;
-  }
-
-  .brand-logo--header {
-    width: 64px;
-    height: 64px;
-  }
-
-  .brand {
-    font-size: 26px;
-  }
-
-  .tagline {
-    font-size: 13px;
-  }
-
   .header-right {
     grid-column: 1 / -1;
     justify-content: flex-start;
-    width: 100%;
-    flex-wrap: wrap;
-    gap: 10px;
   }
 
   .header-nav {
     justify-content: flex-start;
-    width: 100%;
-  }
-
-  .signed-in-menu {
-    margin-left: auto;
-  }
-
-  .avatar-button {
-    width: 40px;
-    height: 40px;
-  }
-
-  .signed-in-dropdown {
-    right: 0;
-    left: auto;
-    width: min(260px, 92vw);
-  }
-
-  .header-actions {
-    width: 100%;
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 10px;
-  }
-
-  .header-actions a,
-  .header-actions .header-link {
-    font-size: 12px;
-    padding: 8px 10px;
-  }
-
-  .header-actions .header-cta--left {
-    grid-column: 1 / -1;
-    margin-right: 0;
   }
 
   .summary {
@@ -1689,21 +1406,6 @@ button span {
   .cache-row {
     grid-template-columns: 1fr;
   }
-
-  .user-card {
-    grid-template-columns: 1fr;
-  }
-
-  .connection-item {
-    flex-direction: column;
-    align-items: flex-start;
-  }
-}
-
-@media (max-width: 480px) {
-  .header-actions {
-    grid-template-columns: 1fr;
-  }
 }
 
 /* Loading spinner */
@@ -1725,16 +1427,6 @@ button span {
   animation: spin 0.9s linear infinite;
 }
 
-.button-spinner {
-  width: 16px;
-  height: 16px;
-  border-width: 2px;
-  box-shadow: none;
-  margin-right: 8px;
-  vertical-align: middle;
-  display: inline-block;
-}
-
 .loading-text {
   font-size: 16px;
   color: var(--ink-muted);
@@ -1804,91 +1496,6 @@ button span {
   border: 1px solid var(--border);
 }
 
-.how-step-grid {
-  display: grid;
-  gap: 16px;
-  grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
-}
-
-.how-step-card {
-  border-radius: 18px;
-  padding: 18px;
-  border: 1px solid var(--border);
-  background: rgba(255, 255, 255, 0.06);
-  display: grid;
-  gap: 10px;
-  position: relative;
-  overflow: hidden;
-}
-
-.how-step-card::before {
-  content: '';
-  position: absolute;
-  inset: 0;
-  opacity: 0.35;
-  pointer-events: none;
-}
-
-.step-jellyseerr::before {
-  background: linear-gradient(135deg, rgba(255, 187, 92, 0.35), transparent 60%);
-}
-
-.step-arr::before {
-  background: linear-gradient(135deg, rgba(94, 204, 255, 0.35), transparent 60%);
-}
-
-.step-prowlarr::before {
-  background: linear-gradient(135deg, rgba(120, 255, 189, 0.35), transparent 60%);
-}
-
-.step-qbit::before {
-  background: linear-gradient(135deg, rgba(255, 133, 200, 0.35), transparent 60%);
-}
-
-.step-jellyfin::before {
-  background: linear-gradient(135deg, rgba(170, 140, 255, 0.35), transparent 60%);
-}
-
-.step-badge {
-  width: 38px;
-  height: 38px;
-  border-radius: 50%;
-  display: grid;
-  place-items: center;
-  font-weight: 700;
-  background: rgba(255, 255, 255, 0.12);
-  border: 1px solid var(--border);
-  color: var(--ink);
-}
-
-.step-note {
-  color: var(--ink-muted);
-  font-size: 14px;
-}
-
-.step-fix-title {
-  font-size: 13px;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: var(--ink-muted);
-}
-
-.step-fix-list {
-  list-style: none;
-  display: grid;
-  gap: 6px;
-  padding: 0;
-  margin: 0;
-}
-
-.step-fix-list li {
-  padding: 8px 10px;
-  border-radius: 10px;
-  background: rgba(255, 255, 255, 0.08);
-  border: 1px solid var(--border);
-  font-size: 13px;
-}
-
 .how-callout {
   border-left: 4px solid var(--accent);
   padding: 16px 18px;
@@ -1897,21 +1504,3 @@ button span {
   display: grid;
   gap: 8px;
 }
-
-.changelog-card {
-  gap: 18px;
-}
-
-.changelog-header {
-  display: grid;
-  gap: 8px;
-}
-
-.changelog-list {
-  list-style: disc;
-  padding-left: 22px;
-  display: grid;
-  gap: 10px;
-  color: var(--ink-muted);
-  font-size: 15px;
-}

frontend/app/how-it-works/page.tsx

@@ -75,64 +75,8 @@ export default function HowItWorksPage() {
         </ol>
       </section>
 
-      <section className="how-flow">
-        <h2>Steps and fixes (simple and visual)</h2>
-        <div className="how-step-grid">
-          <article className="how-step-card step-jellyseerr">
-            <div className="step-badge">1</div>
-            <h3>Request sent</h3>
-            <p className="step-note">Jellyseerr holds your request and approval.</p>
-            <div className="step-fix-title">Fixes you can try</div>
-            <ul className="step-fix-list">
-              <li>Add to library queue (if it was approved but never added)</li>
-            </ul>
-          </article>
-
-          <article className="how-step-card step-arr">
-            <div className="step-badge">2</div>
-            <h3>Added to the library list</h3>
-            <p className="step-note">Sonarr/Radarr decide what quality to get.</p>
-            <div className="step-fix-title">Fixes you can try</div>
-            <ul className="step-fix-list">
-              <li>Search for releases (see options)</li>
-              <li>Search and auto-download (let it pick for you)</li>
-            </ul>
-          </article>
-
-          <article className="how-step-card step-prowlarr">
-            <div className="step-badge">3</div>
-            <h3>Searching for sources</h3>
-            <p className="step-note">Prowlarr checks your torrent providers.</p>
-            <div className="step-fix-title">Fixes you can try</div>
-            <ul className="step-fix-list">
-              <li>Search for releases (show a list to choose)</li>
-            </ul>
-          </article>
-
-          <article className="how-step-card step-qbit">
-            <div className="step-badge">4</div>
-            <h3>Downloading the file</h3>
-            <p className="step-note">qBittorrent downloads the selected match.</p>
-            <div className="step-fix-title">Fixes you can try</div>
-            <ul className="step-fix-list">
-              <li>Resume download (only if it already exists there)</li>
-            </ul>
-          </article>
-
-          <article className="how-step-card step-jellyfin">
-            <div className="step-badge">5</div>
-            <h3>Ready to watch</h3>
-            <p className="step-note">Jellyfin shows it in your library.</p>
-            <div className="step-fix-title">What to do next</div>
-            <ul className="step-fix-list">
-              <li>Open in Jellyfin (watch it)</li>
-            </ul>
-          </article>
-        </div>
-      </section>
-
       <section className="how-callout">
-        <h2>Why Magent sometimes says &quot;waiting&quot;</h2>
+        <h2>Why Magent sometimes says “waiting”</h2>
         <p>
           If the search helper cannot find a match yet, Magent will say there is nothing to grab.
           That does not mean it is broken. It usually means the release is not available yet.

frontend/app/layout.tsx

@@ -5,7 +5,6 @@ import HeaderIdentity from './ui/HeaderIdentity'
 import ThemeToggle from './ui/ThemeToggle'
 import BrandingFavicon from './ui/BrandingFavicon'
 import BrandingLogo from './ui/BrandingLogo'
-import SiteStatus from './ui/SiteStatus'
 
 export const metadata = {
   title: 'Magent',
@@ -29,14 +28,13 @@ export default function RootLayout({ children }: { children: ReactNode }) {
               </a>
             </div>
             <div className="header-right">
-              <ThemeToggle />
               <HeaderIdentity />
+              <ThemeToggle />
             </div>
             <div className="header-nav">
               <HeaderActions />
             </div>
           </header>
-          <SiteStatus />
           {children}
         </div>
       </body>

frontend/app/lib/auth.ts

@@ -23,3 +23,37 @@ export const authFetch = (input: RequestInfo | URL, init?: RequestInit) => {
   }
   return fetch(input, { ...init, headers })
 }
+
+export class UnauthorizedError extends Error {
+  constructor() {
+    super('Unauthorized')
+    this.name = 'UnauthorizedError'
+  }
+}
+
+export class ForbiddenError extends Error {
+  constructor() {
+    super('Forbidden')
+    this.name = 'ForbiddenError'
+  }
+}
+
+export const authFetchOrThrow = async (input: RequestInfo | URL, init?: RequestInit) => {
+  const response = await authFetch(input, init)
+  if (response.status === 401) {
+    clearToken()
+    throw new UnauthorizedError()
+  }
+  if (response.status === 403) {
+    throw new ForbiddenError()
+  }
+  return response
+}
+
+export const readResponseText = async (response: Response) => {
+  try {
+    return (await response.text()).trim()
+  } catch {
+    return ''
+  }
+}

frontend/app/page.tsx

@@ -2,7 +2,13 @@
 
 import { useRouter } from 'next/navigation'
 import { useEffect, useState } from 'react'
-import { authFetch, getApiBase, getToken, clearToken } from './lib/auth'
+import {
+  authFetchOrThrow,
+  ForbiddenError,
+  getApiBase,
+  getToken,
+  UnauthorizedError,
+} from './lib/auth'
 
 export default function HomePage() {
   const router = useRouter()
@@ -30,8 +36,6 @@ export default function HomePage() {
   >(null)
   const [servicesLoading, setServicesLoading] = useState(false)
   const [servicesError, setServicesError] = useState<string | null>(null)
-  const [serviceTesting, setServiceTesting] = useState<Record<string, boolean>>({})
-  const [serviceTestResults, setServiceTestResults] = useState<Record<string, string | null>>({})
 
   const submit = (event: React.FormEvent) => {
     event.preventDefault()
@@ -44,61 +48,6 @@ export default function HomePage() {
     void runSearch(trimmed)
   }
 
-  const toServiceSlug = (name: string) => name.toLowerCase().replace(/[^a-z0-9]/g, '')
-
-  const updateServiceStatus = (name: string, status: string, message?: string) => {
-    setServicesStatus((prev) => {
-      if (!prev) return prev
-      return {
-        ...prev,
-        services: prev.services.map((service) =>
-          service.name === name ? { ...service, status, message } : service
-        ),
-      }
-    })
-  }
-
-  const testService = async (name: string) => {
-    const slug = toServiceSlug(name)
-    setServiceTesting((prev) => ({ ...prev, [name]: true }))
-    setServiceTestResults((prev) => ({ ...prev, [name]: null }))
-    try {
-      const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/status/services/${slug}/test`, {
-        method: 'POST',
-      })
-      if (!response.ok) {
-        if (response.status === 401) {
-          clearToken()
-          router.push('/login')
-          return
-        }
-        const text = await response.text()
-        throw new Error(text || `Service test failed: ${response.status}`)
-      }
-      const data = await response.json()
-      const status = data?.status ?? 'unknown'
-      const message =
-        data?.message ||
-        (status === 'up'
-          ? 'API OK'
-          : status === 'down'
-            ? 'API unreachable'
-            : status === 'degraded'
-              ? 'Health warnings'
-              : status === 'not_configured'
-                ? 'Not configured'
-                : 'Unknown')
-      setServiceTestResults((prev) => ({ ...prev, [name]: message }))
-      updateServiceStatus(name, status, data?.message)
-    } catch (error) {
-      console.error(error)
-      setServiceTestResults((prev) => ({ ...prev, [name]: 'Test failed' }))
-    } finally {
-      setServiceTesting((prev) => ({ ...prev, [name]: false }))
-    }
-  }
-
   useEffect(() => {
     if (!getToken()) {
       router.push('/login')
@@ -109,13 +58,8 @@ export default function HomePage() {
       setRecentError(null)
       try {
         const baseUrl = getApiBase()
-        const meResponse = await authFetch(`${baseUrl}/auth/me`)
+        const meResponse = await authFetchOrThrow(`${baseUrl}/auth/me`)
         if (!meResponse.ok) {
-          if (meResponse.status === 401) {
-            clearToken()
-            router.push('/login')
-            return
-          }
           throw new Error(`Auth failed: ${meResponse.status}`)
         }
         const me = await meResponse.json()
@@ -123,15 +67,10 @@ export default function HomePage() {
         setRole(userRole)
         setAuthReady(true)
         const take = userRole === 'admin' ? 50 : 6
-        const response = await authFetch(
+        const response = await authFetchOrThrow(
           `${baseUrl}/requests/recent?take=${take}&days=${recentDays}`
         )
         if (!response.ok) {
-          if (response.status === 401) {
-            clearToken()
-            router.push('/login')
-            return
-          }
           throw new Error(`Recent requests failed: ${response.status}`)
         }
         const data = await response.json()
@@ -156,6 +95,14 @@ export default function HomePage() {
           )
         }
       } catch (error) {
+        if (error instanceof UnauthorizedError) {
+          router.push('/login')
+          return
+        }
+        if (error instanceof ForbiddenError) {
+          router.push('/')
+          return
+        }
         console.error(error)
         setRecentError('Recent requests are not available right now.')
       } finally {
@@ -164,7 +111,7 @@ export default function HomePage() {
     }
 
     load()
-  }, [recentDays])
+  }, [recentDays, router])
 
   useEffect(() => {
     if (!authReady) {
@@ -175,18 +122,21 @@ export default function HomePage() {
       setServicesError(null)
       try {
         const baseUrl = getApiBase()
-        const response = await authFetch(`${baseUrl}/status/services`)
+        const response = await authFetchOrThrow(`${baseUrl}/status/services`)
         if (!response.ok) {
-          if (response.status === 401) {
-            clearToken()
-            router.push('/login')
-            return
-          }
           throw new Error(`Service status failed: ${response.status}`)
         }
         const data = await response.json()
         setServicesStatus(data)
       } catch (error) {
+        if (error instanceof UnauthorizedError) {
+          router.push('/login')
+          return
+        }
+        if (error instanceof ForbiddenError) {
+          router.push('/')
+          return
+        }
         console.error(error)
         setServicesError('Service status is not available right now.')
       } finally {
@@ -202,13 +152,8 @@ export default function HomePage() {
   const runSearch = async (term: string) => {
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/requests/search?query=${encodeURIComponent(term)}`)
+      const response = await authFetchOrThrow(`${baseUrl}/requests/search?query=${encodeURIComponent(term)}`)
       if (!response.ok) {
-        if (response.status === 401) {
-          clearToken()
-          router.push('/login')
-          return
-        }
         throw new Error(`Search failed: ${response.status}`)
       }
       const data = await response.json()
@@ -225,6 +170,14 @@ export default function HomePage() {
         setSearchError(null)
       }
     } catch (error) {
+      if (error instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
+      if (error instanceof ForbiddenError) {
+        router.push('/')
+        return
+      }
       console.error(error)
       setSearchError('Search failed. Try a request ID instead.')
       setSearchResults([])
@@ -271,37 +224,21 @@ export default function HomePage() {
                   return order.map((name) => {
                     const item = items.find((entry) => entry.name === name)
                     const status = item?.status ?? 'unknown'
-                    const testing = serviceTesting[name] ?? false
                     return (
                       <div key={name} className={`system-item system-${status}`}>
                         <span className="system-dot" />
-                        <div className="system-meta">
+                        <span className="system-name">{name}</span>
-                          <span className="system-name">{name}</span>
+                        <span className="system-state">
-                          {serviceTestResults[name] && (
+                          {status === 'up'
-                            <span className="system-test-message">{serviceTestResults[name]}</span>
+                            ? 'Up'
-                          )}
+                            : status === 'down'
-                        </div>
+                              ? 'Down'
-                        <div className="system-actions">
+                              : status === 'degraded'
-                          <span className="system-state">
+                                ? 'Needs attention'
-                            {status === 'up'
+                                : status === 'not_configured'
-                              ? 'Up'
+                                  ? 'Not configured'
-                              : status === 'down'
+                                  : 'Unknown'}
-                                ? 'Down'
+                        </span>
-                                : status === 'degraded'
-                                  ? 'Needs attention'
-                                  : status === 'not_configured'
-                                    ? 'Not configured'
-                                    : 'Unknown'}
-                          </span>
-                          <button
-                            type="button"
-                            className="system-test"
-                            onClick={() => void testService(name)}
-                            disabled={testing}
-                          >
-                            {testing ? 'Testing...' : 'Test'}
-                          </button>
-                        </div>
                       </div>
                     )
                   })

frontend/app/profile/page.tsx

@@ -2,7 +2,13 @@
 
 import { useEffect, useState } from 'react'
 import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
+import {
+  authFetchOrThrow,
+  getApiBase,
+  getToken,
+  readResponseText,
+  UnauthorizedError,
+} from '../lib/auth'
 
 type ProfileInfo = {
   username: string
@@ -10,65 +16,9 @@ type ProfileInfo = {
   auth_provider: string
 }
 
-type ProfileStats = {
-  total: number
-  ready: number
-  pending: number
-  in_progress: number
-  declined: number
-  working: number
-  partial: number
-  approved: number
-  last_request_at?: string | null
-  share: number
-  global_total: number
-  most_active_user?: { username: string; total: number } | null
-}
-
-type ActivityEntry = {
-  ip: string
-  user_agent: string
-  first_seen_at: string
-  last_seen_at: string
-  hit_count: number
-}
-
-type ProfileActivity = {
-  last_ip?: string | null
-  last_user_agent?: string | null
-  last_seen_at?: string | null
-  device_count: number
-  recent: ActivityEntry[]
-}
-
-type ProfileResponse = {
-  user: ProfileInfo
-  stats: ProfileStats
-  activity: ProfileActivity
-}
-
-const formatDate = (value?: string | null) => {
-  if (!value) return 'Never'
-  const date = new Date(value)
-  if (Number.isNaN(date.valueOf())) return value
-  return date.toLocaleString()
-}
-
-const parseBrowser = (agent?: string | null) => {
-  if (!agent) return 'Unknown'
-  const value = agent.toLowerCase()
-  if (value.includes('edg/')) return 'Edge'
-  if (value.includes('chrome/') && !value.includes('edg/')) return 'Chrome'
-  if (value.includes('firefox/')) return 'Firefox'
-  if (value.includes('safari/') && !value.includes('chrome/')) return 'Safari'
-  return 'Unknown'
-}
-
 export default function ProfilePage() {
   const router = useRouter()
   const [profile, setProfile] = useState<ProfileInfo | null>(null)
-  const [stats, setStats] = useState<ProfileStats | null>(null)
-  const [activity, setActivity] = useState<ProfileActivity | null>(null)
   const [currentPassword, setCurrentPassword] = useState('')
   const [newPassword, setNewPassword] = useState('')
   const [status, setStatus] = useState<string | null>(null)
@@ -82,22 +32,22 @@ export default function ProfilePage() {
     const load = async () => {
       try {
         const baseUrl = getApiBase()
-        const response = await authFetch(`${baseUrl}/auth/profile`)
+        const response = await authFetchOrThrow(`${baseUrl}/auth/me`)
         if (!response.ok) {
-          clearToken()
           router.push('/login')
           return
         }
         const data = await response.json()
-        const user = data?.user ?? {}
         setProfile({
-          username: user?.username ?? 'Unknown',
+          username: data?.username ?? 'Unknown',
-          role: user?.role ?? 'user',
+          role: data?.role ?? 'user',
-          auth_provider: user?.auth_provider ?? 'local',
+          auth_provider: data?.auth_provider ?? 'local',
         })
-        setStats(data?.stats ?? null)
-        setActivity(data?.activity ?? null)
       } catch (err) {
+        if (err instanceof UnauthorizedError) {
+          router.push('/login')
+          return
+        }
         console.error(err)
         setStatus('Could not load your profile.')
       } finally {
@@ -116,7 +66,7 @@ export default function ProfilePage() {
     }
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/auth/password`, {
+      const response = await authFetchOrThrow(`${baseUrl}/auth/password`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -125,13 +75,17 @@ export default function ProfilePage() {
         }),
       })
       if (!response.ok) {
-        const text = await response.text()
+        const text = await readResponseText(response)
         throw new Error(text || 'Update failed')
       }
       setCurrentPassword('')
       setNewPassword('')
       setStatus('Password updated.')
     } catch (err) {
+      if (err instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
       console.error(err)
       setStatus('Could not update password. Check your current password.')
     }
@@ -150,78 +104,6 @@ export default function ProfilePage() {
           {profile.auth_provider}.
         </div>
       )}
-      <div className="profile-grid">
-        <section className="profile-section">
-          <h2>Account stats</h2>
-          <div className="stat-grid">
-            <div className="stat-card">
-              <div className="stat-label">Requests submitted</div>
-              <div className="stat-value">{stats?.total ?? 0}</div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">Ready to watch</div>
-              <div className="stat-value">{stats?.ready ?? 0}</div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">In progress</div>
-              <div className="stat-value">{stats?.in_progress ?? 0}</div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">Pending approval</div>
-              <div className="stat-value">{stats?.pending ?? 0}</div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">Declined</div>
-              <div className="stat-value">{stats?.declined ?? 0}</div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">Last request</div>
-              <div className="stat-value stat-value--small">
-                {formatDate(stats?.last_request_at)}
-              </div>
-            </div>
-            <div className="stat-card">
-              <div className="stat-label">Share of all requests</div>
-              <div className="stat-value">
-                {stats?.global_total
-                  ? `${Math.round((stats.share || 0) * 1000) / 10}%`
-                  : '0%'}
-              </div>
-            </div>
-            {profile?.role === 'admin' ? (
-              <div className="stat-card">
-                <div className="stat-label">Most active user</div>
-                <div className="stat-value stat-value--small">
-                  {stats?.most_active_user
-                    ? `${stats.most_active_user.username} (${stats.most_active_user.total})`
-                    : 'N/A'}
-                </div>
-              </div>
-            ) : null}
-          </div>
-        </section>
-        <section className="profile-section">
-          <h2>Connection history</h2>
-          <div className="status-banner">
-            Last seen {formatDate(activity?.last_seen_at)} from {activity?.last_ip ?? 'Unknown'}.
-          </div>
-          <div className="connection-list">
-            {(activity?.recent ?? []).map((entry, index) => (
-              <div key={`${entry.ip}-${entry.last_seen_at}-${index}`} className="connection-item">
-                <div>
-                  <div className="connection-label">{parseBrowser(entry.user_agent)}</div>
-                  <div className="meta">IP: {entry.ip}</div>
-                  <div className="meta">Last seen: {formatDate(entry.last_seen_at)}</div>
-                </div>
-                <div className="connection-count">{entry.hit_count} visits</div>
-              </div>
-            ))}
-            {activity && activity.recent.length === 0 ? (
-              <div className="status-banner">No connection history yet.</div>
-            ) : null}
-          </div>
-        </section>
-      </div>
       {profile?.auth_provider !== 'local' ? (
         <div className="status-banner">
           Password changes are only available for local Magent accounts.

frontend/app/requests/[id]/page.tsx

@@ -1,9 +1,16 @@
 'use client'
 
-import Image from 'next/image'
 import { useEffect, useState } from 'react'
 import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../../lib/auth'
+import {
+  authFetch,
+  authFetchOrThrow,
+  clearToken,
+  getApiBase,
+  getToken,
+  readResponseText,
+  UnauthorizedError,
+} from '../../lib/auth'
 
 type TimelineHop = {
   service: string
@@ -34,7 +41,6 @@ type ReleaseOption = {
   seeders?: number
   leechers?: number
   protocol?: string
-  publishDate?: string
   infoUrl?: string
   downloadUrl?: string
 }
@@ -125,7 +131,7 @@ const friendlyState = (value: string) => {
   const map: Record<string, string> = {
     REQUESTED: 'Waiting for approval',
     APPROVED: 'Approved and queued',
-    NEEDS_ADD: 'Push to Sonarr/Radarr',
+    NEEDS_ADD: 'Needs adding to the library',
     ADDED_TO_ARR: 'Added to the library queue',
     SEARCHING: 'Searching for releases',
     GRABBED: 'Download queued',
@@ -157,7 +163,7 @@ const friendlyTimelineStatus = (service: string, status: string) => {
   }
   if (service === 'Sonarr/Radarr') {
     const map: Record<string, string> = {
-      missing: 'Push to Sonarr/Radarr',
+      missing: 'Not added yet',
       added: 'Added to the library queue',
       searching: 'Searching for releases',
       available: 'Ready to watch',
@@ -252,7 +258,7 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
     }
 
     load()
-  }, [params.id, router])
+  }, [params.id])
 
   if (loading) {
     return (
@@ -276,11 +282,9 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
   const downloadHop = snapshot.timeline.find((hop) => hop.service === 'qBittorrent')
   const downloadState = downloadHop?.details?.summary ?? downloadHop?.status ?? 'Unknown'
   const jellyfinAvailable = Boolean(snapshot.raw?.jellyfin?.available)
-  const arrStageLabel =
-    snapshot.state === 'NEEDS_ADD' ? 'Push to Sonarr/Radarr' : 'Library queue'
   const pipelineSteps = [
     { key: 'Jellyseerr', label: 'Jellyseerr' },
-    { key: 'Sonarr/Radarr', label: arrStageLabel },
+    { key: 'Sonarr/Radarr', label: 'Library queue' },
     { key: 'Prowlarr', label: 'Search' },
     { key: 'qBittorrent', label: 'Download' },
     { key: 'Jellyfin', label: 'Jellyfin' },
@@ -312,14 +316,11 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
       <div className="request-header">
         <div className="request-header-main">
           {resolvedPoster && (
-            <Image
+            <img
               className="request-poster"
               src={resolvedPoster}
               alt={`${snapshot.title} poster`}
-              width={90}
+              loading="lazy"
-              height={135}
-              sizes="90px"
-              unoptimized
             />
           )}
           <div>
@@ -509,16 +510,11 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
                   setModalMessage(null)
                 }
                 try {
-                  const response = await authFetch(`${baseUrl}/requests/${snapshot.request_id}/${path}`, {
+                  const response = await authFetchOrThrow(`${baseUrl}/requests/${snapshot.request_id}/${path}`, {
                     method: 'POST',
                   })
                   if (!response.ok) {
-                    if (response.status === 401) {
+                    const text = await readResponseText(response)
-                      clearToken()
-                      router.push('/login')
-                      return
-                    }
-                    const text = await response.text()
                     throw new Error(text || `Request failed: ${response.status}`)
                   }
                   const data = await response.json()
@@ -545,6 +541,10 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
                     setModalMessage(message)
                   }
                 } catch (error) {
+                  if (error instanceof UnauthorizedError) {
+                    router.push('/login')
+                    return
+                  }
                   console.error(error)
                   const message = `${action.label} failed. Check the backend logs.`
                   setActionMessage(message)
@@ -589,7 +589,7 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
                       if (!ok) return
                       const baseUrl = getApiBase()
                       try {
-                        const response = await authFetch(
+                        const response = await authFetchOrThrow(
                           `${baseUrl}/requests/${snapshot.request_id}/actions/grab`,
                           {
                             method: 'POST',
@@ -597,29 +597,21 @@ export default function RequestTimelinePage({ params }: { params: { id: string }
                             body: JSON.stringify({
                               guid: release.guid,
                               indexerId: release.indexerId,
-                              indexerName: release.indexer,
                               downloadUrl: release.downloadUrl,
-                              title: release.title,
-                              size: release.size,
-                              protocol: release.protocol,
-                              publishDate: release.publishDate,
-                              seeders: release.seeders,
-                              leechers: release.leechers,
                             }),
                           }
                         )
                         if (!response.ok) {
-                          if (response.status === 401) {
+                          const text = await readResponseText(response)
-                            clearToken()
-                            router.push('/login')
-                            return
-                          }
-                          const text = await response.text()
                           throw new Error(text || `Request failed: ${response.status}`)
                         }
-                        setActionMessage('Download sent to qBittorrent.')
+                        setActionMessage('Download sent to Sonarr/Radarr.')
-                        setModalMessage('Download sent to qBittorrent.')
+                        setModalMessage('Download sent to Sonarr/Radarr.')
                       } catch (error) {
+                        if (error instanceof UnauthorizedError) {
+                          router.push('/login')
+                          return
+                        }
                         console.error(error)
                         const message = 'Download failed. Check the logs.'
                         setActionMessage(message)

frontend/app/ui/AdminSidebar.tsx

@@ -17,14 +17,14 @@ const NAV_GROUPS = [
   {
     title: 'Requests',
     items: [
-      { href: '/admin/requests', label: 'Request sync' },
+      { href: '/admin/requests', label: 'Request syncing' },
-      { href: '/admin/cache', label: 'Cache Control' },
+      { href: '/admin/artwork', label: 'Artwork' },
+      { href: '/admin/cache', label: 'Cache' },
     ],
   },
   {
     title: 'Admin',
     items: [
-      { href: '/admin/site', label: 'Site' },
       { href: '/users', label: 'Users' },
       { href: '/admin/logs', label: 'Activity log' },
       { href: '/admin/maintenance', label: 'Maintenance' },

frontend/app/ui/HeaderActions.tsx

@@ -32,6 +32,14 @@ export default function HeaderActions() {
     void load()
   }, [])
 
+  const signOut = () => {
+    clearToken()
+    setSignedIn(false)
+    if (typeof window !== 'undefined') {
+      window.location.href = '/login'
+    }
+  }
+
   if (!signedIn) {
     return null
   }
@@ -41,7 +49,11 @@ export default function HeaderActions() {
       <a className="header-cta header-cta--left" href="/feedback">Send feedback</a>
       <a href="/">Requests</a>
       <a href="/how-it-works">How it works</a>
+      <a href="/profile">My profile</a>
       {role === 'admin' && <a href="/admin">Settings</a>}
+      <button type="button" className="header-link" onClick={signOut}>
+        Sign out
+      </button>
     </div>
   )
 }

frontend/app/ui/HeaderIdentity.tsx

@@ -1,41 +1,35 @@
 'use client'
 
 import { useEffect, useState } from 'react'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
+import { authFetchOrThrow, getApiBase, getToken, UnauthorizedError } from '../lib/auth'
 
 export default function HeaderIdentity() {
-  const [identity, setIdentity] = useState<{ username: string; role?: string } | null>(null)
+  const [identity, setIdentity] = useState<string | null>(null)
-  const [buildNumber, setBuildNumber] = useState<string | null>(null)
   const [open, setOpen] = useState(false)
 
   useEffect(() => {
     const token = getToken()
     if (!token) {
       setIdentity(null)
-      setBuildNumber(null)
       return
     }
     const load = async () => {
       try {
         const baseUrl = getApiBase()
-        const response = await authFetch(`${baseUrl}/auth/me`)
+        const response = await authFetchOrThrow(`${baseUrl}/auth/me`)
         if (!response.ok) {
-          clearToken()
           setIdentity(null)
           return
         }
         const data = await response.json()
         if (data?.username) {
-          setIdentity({ username: data.username, role: data.role })
+          setIdentity(`${data.username}${data.role ? ` (${data.role})` : ''}`)
-        }
-        const siteResponse = await fetch(`${baseUrl}/site/public`)
-        if (siteResponse.ok) {
-          const siteInfo = await siteResponse.json()
-          if (siteInfo?.buildNumber) {
-            setBuildNumber(siteInfo.buildNumber)
-          }
         }
       } catch (err) {
+        if (err instanceof UnauthorizedError) {
+          setIdentity(null)
+          return
+        }
         console.error(err)
         setIdentity(null)
       }
@@ -47,42 +41,14 @@ export default function HeaderIdentity() {
     return null
   }
 
-  const label = `${identity.username}${identity.role ? ` (${identity.role})` : ''}`
-  const initial = identity.username.slice(0, 1).toUpperCase()
-  const signOut = () => {
-    clearToken()
-    if (typeof window !== 'undefined') {
-      window.location.href = '/login'
-    }
-  }
-
   return (
     <div className="signed-in-menu">
-      <button
+      <button type="button" className="signed-in" onClick={() => setOpen((prev) => !prev)}>
-        type="button"
+        Signed in as {identity}
-        className="avatar-button"
-        onClick={() => setOpen((prev) => !prev)}
-        aria-haspopup="true"
-        aria-expanded={open}
-        title={label}
-      >
-        {initial}
       </button>
       {open && (
         <div className="signed-in-dropdown">
-          <div className="signed-in-header">Signed in as {label}</div>
+          <a href="/profile">My profile</a>
-          <div className="signed-in-actions">
-            <a href="/profile" onClick={() => setOpen(false)}>
-              My profile
-            </a>
-            <a href="/changelog" onClick={() => setOpen(false)}>
-              Changelog
-            </a>
-            <button type="button" className="signed-in-signout" onClick={signOut}>
-              Sign out
-            </button>
-          </div>
-          {buildNumber ? <div className="signed-in-build">Build {buildNumber}</div> : null}
         </div>
       )}
     </div>

frontend/app/ui/SiteStatus.tsx

@@ -1,62 +0,0 @@
-'use client'
-
-import { useEffect, useState } from 'react'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
-
-type BannerInfo = {
-  enabled: boolean
-  message: string
-  tone?: string
-}
-
-type SiteInfo = {
-  buildNumber?: string
-  banner?: BannerInfo
-}
-
-const buildRequest = () => {
-  const token = getToken()
-  const baseUrl = getApiBase()
-  const url = token ? `${baseUrl}/site/info` : `${baseUrl}/site/public`
-  const fetcher = token ? authFetch : fetch
-  return { token, url, fetcher }
-}
-
-export default function SiteStatus() {
-  const [info, setInfo] = useState<SiteInfo | null>(null)
-
-  useEffect(() => {
-    let active = true
-    const load = async () => {
-      try {
-        const { token, url, fetcher } = buildRequest()
-        const response = await fetcher(url)
-        if (!response.ok) {
-          if (response.status === 401 && token) {
-            clearToken()
-          }
-          return
-        }
-        const data = await response.json()
-        if (!active) return
-        setInfo(data)
-      } catch (err) {
-        console.error(err)
-      }
-    }
-    void load()
-    return () => {
-      active = false
-    }
-  }, [])
-
-  const banner = info?.banner
-  const tone = banner?.tone || 'info'
-  return (
-    <>
-      {banner?.enabled && banner.message ? (
-        <div className={`site-banner site-banner--${tone}`}>{banner.message}</div>
-      ) : null}
-    </>
-  )
-}

frontend/app/users/page.tsx

@@ -2,7 +2,13 @@
 
 import { useEffect, useState } from 'react'
 import { useRouter } from 'next/navigation'
-import { authFetch, clearToken, getApiBase, getToken } from '../lib/auth'
+import {
+  authFetchOrThrow,
+  ForbiddenError,
+  getApiBase,
+  getToken,
+  UnauthorizedError,
+} from '../lib/auth'
 import AdminShell from '../ui/AdminShell'
 
 type AdminUser = {
@@ -25,23 +31,12 @@ export default function UsersPage() {
   const [users, setUsers] = useState<AdminUser[]>([])
   const [error, setError] = useState<string | null>(null)
   const [loading, setLoading] = useState(true)
-  const [jellyfinSyncStatus, setJellyfinSyncStatus] = useState<string | null>(null)
-  const [jellyfinSyncBusy, setJellyfinSyncBusy] = useState(false)
 
   const loadUsers = async () => {
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/admin/users`)
+      const response = await authFetchOrThrow(`${baseUrl}/admin/users`)
       if (!response.ok) {
-        if (response.status === 401) {
-          clearToken()
-          router.push('/login')
-          return
-        }
-        if (response.status === 403) {
-          router.push('/')
-          return
-        }
         throw new Error('Could not load users.')
       }
       const data = await response.json()
@@ -60,6 +55,14 @@ export default function UsersPage() {
       }
       setError(null)
     } catch (err) {
+      if (err instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
+      if (err instanceof ForbiddenError) {
+        router.push('/')
+        return
+      }
       console.error(err)
       setError('Could not load user list.')
     } finally {
@@ -70,7 +73,7 @@ export default function UsersPage() {
   const toggleUserBlock = async (username: string, blocked: boolean) => {
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(
+      const response = await authFetchOrThrow(
         `${baseUrl}/admin/users/${encodeURIComponent(username)}/${blocked ? 'block' : 'unblock'}`,
         { method: 'POST' }
       )
@@ -79,6 +82,14 @@ export default function UsersPage() {
       }
       await loadUsers()
     } catch (err) {
+      if (err instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
+      if (err instanceof ForbiddenError) {
+        router.push('/')
+        return
+      }
       console.error(err)
       setError('Could not update user access.')
     }
@@ -87,7 +98,7 @@ export default function UsersPage() {
   const updateUserRole = async (username: string, role: string) => {
     try {
       const baseUrl = getApiBase()
-      const response = await authFetch(
+      const response = await authFetchOrThrow(
         `${baseUrl}/admin/users/${encodeURIComponent(username)}/role`,
         {
           method: 'POST',
@@ -100,33 +111,19 @@ export default function UsersPage() {
       }
       await loadUsers()
     } catch (err) {
+      if (err instanceof UnauthorizedError) {
+        router.push('/login')
+        return
+      }
+      if (err instanceof ForbiddenError) {
+        router.push('/')
+        return
+      }
       console.error(err)
       setError('Could not update user role.')
     }
   }
 
-  const syncJellyfinUsers = async () => {
-    setJellyfinSyncStatus(null)
-    setJellyfinSyncBusy(true)
-    try {
-      const baseUrl = getApiBase()
-      const response = await authFetch(`${baseUrl}/admin/jellyfin/users/sync`, {
-        method: 'POST',
-      })
-      if (!response.ok) {
-        const text = await response.text()
-        throw new Error(text || 'Sync failed')
-      }
-      const data = await response.json()
-      setJellyfinSyncStatus(`Synced ${data?.imported ?? 0} Jellyfin users.`)
-      await loadUsers()
-    } catch (err) {
-      console.error(err)
-      setJellyfinSyncStatus('Could not sync Jellyfin users.')
-    } finally {
-      setJellyfinSyncBusy(false)
-    }
-  }
 
   useEffect(() => {
     if (!getToken()) {
@@ -145,19 +142,13 @@ export default function UsersPage() {
       title="Users"
       subtitle="Manage who can use Magent."
       actions={
-        <>
+        <button type="button" onClick={loadUsers}>
-          <button type="button" onClick={loadUsers}>
+          Reload list
-            Reload list
+        </button>
-          </button>
-          <button type="button" onClick={syncJellyfinUsers} disabled={jellyfinSyncBusy}>
-            {jellyfinSyncBusy ? 'Syncing Jellyfin users...' : 'Sync Jellyfin users'}
-          </button>
-        </>
       }
     >
       <section className="admin-section">
         {error && <div className="error-banner">{error}</div>}
-        {jellyfinSyncStatus && <div className="status-banner">{jellyfinSyncStatus}</div>}
         {users.length === 0 ? (
           <div className="status-banner">No users found yet.</div>
         ) : (
@@ -166,11 +157,9 @@ export default function UsersPage() {
               <div key={user.username} className="summary-card user-card">
                 <div>
                   <strong>{user.username}</strong>
-                  <div className="user-meta">
+                  <span className="meta">Role: {user.role}</span>
-                    <span className="meta">Role: {user.role}</span>
+                  <span className="meta">Login type: {user.authProvider || 'local'}</span>
-                    <span className="meta">Login type: {user.authProvider || 'local'}</span>
+                  <span className="meta">Last login: {formatLastLogin(user.lastLoginAt)}</span>
-                    <span className="meta">Last login: {formatLastLogin(user.lastLoginAt)}</span>
-                  </div>
                 </div>
                 <div className="user-actions">
                   <label className="toggle">

frontend/next-env.d.ts

@@ -1,2 +1,5 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/basic-features/typescript for more information.

frontend/tsconfig.json

@@ -1,7 +1,11 @@
 {
   "compilerOptions": {
     "target": "ES2019",
-    "lib": ["dom", "dom.iterable", "esnext"],
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
     "allowJs": false,
     "skipLibCheck": true,
     "strict": true,
@@ -12,8 +16,20 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "jsx": "preserve",
-    "incremental": true
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
   },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+  "include": [
-  "exclude": ["node_modules"]
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
 }

scripts/build_release.ps1

@@ -1,26 +0,0 @@
-$ErrorActionPreference = "Stop"
-
-$repoRoot = Resolve-Path "$PSScriptRoot\\.."
-Set-Location $repoRoot
-
-$now = Get-Date
-$buildNumber = "{0}{1}{2}{3}{4}" -f $now.ToString("dd"), $now.ToString("M"), $now.ToString("yy"), $now.ToString("HH"), $now.ToString("mm")
-
-Write-Host "Build number: $buildNumber"
-
-git tag $buildNumber
-git push origin $buildNumber
-
-$backendImage = "rephl3xnz/magent-backend:$buildNumber"
-$frontendImage = "rephl3xnz/magent-frontend:$buildNumber"
-
-docker build -f backend/Dockerfile -t $backendImage --build-arg BUILD_NUMBER=$buildNumber .
-docker build -f frontend/Dockerfile -t $frontendImage frontend
-
-docker tag $backendImage rephl3xnz/magent-backend:latest
-docker tag $frontendImage rephl3xnz/magent-frontend:latest
-
-docker push $backendImage
-docker push $frontendImage
-docker push rephl3xnz/magent-backend:latest
-docker push rephl3xnz/magent-frontend:latest