merge branch 'develop' into 'main' - Release v1.7.35

- Update README Proxy Routes section to explicitly state only a selective subset of endpoints is exposed
- Replace wildcard API endpoint listings with complete list of 30 specific implemented proxy endpoints
- Update OpenAPI tag descriptions for Sonarr/Radarr to clarify selective proxy scope

.dockerignore

@@ -1,3 +1,4 @@
+# Docker build context ignores
 node_modules/
 .env
 .env.example
@@ -7,7 +8,8 @@ node_modules/
 .DS_Store
 *.log
 **/*.log
-client/
+client/node_modules/
+client/dist/
 dist/
 build/
 coverage/

.env.sample

@@ -35,6 +35,13 @@ SOFARR_WEBHOOK_SECRET=your-webhook-secret-here
 # Example: https://sofarr.example.com or https://192.168.1.100:3001
 SOFARR_BASE_URL=https://your-sofarr-url
 
+# Optional dedicated base URL for webhooks (e.g. for reverse proxies / docker networking)
+# If configured, webhook registration in Sonarr, Radarr, and Ombi will use this URL.
+# Useful if those services reside in the same local network/docker container setup and
+# cannot route to the public SOFARR_BASE_URL due to loopback/DNS restrictions (avoiding 503s).
+# Example: http://sofarr:3001 or http://192.168.1.50:3001
+# SOFARR_WEBHOOK_BASE_URL=http://sofarr:3001
+
 # --- Webhook Polling Optimization (Phase 5) ---
 
 # Minutes of silence after which the poller falls back to a full poll
@@ -157,6 +164,15 @@ RADARR_INSTANCES=[{"name":"main","url":"https://radarr.example.com","apiKey":"yo
 # RADARR_URL=https://radarr.example.com
 # RADARR_API_KEY=your-radarr-api-key
 
+# =============================================================================
+# OMBI (Request Management - Optional)
+# =============================================================================
+OMBI_URL=https://ombi.example.com
+OMBI_API_KEY=your-ombi-api-key-here
+# Optional: Delay in milliseconds to wait before refreshing the cache after receiving an Ombi webhook
+# to resolve the race condition where Ombi fires the webhook before committing to its database.
+# OMBI_WEBHOOK_REFRESH_DELAY_MS=2000
+
 # =============================================================================
 # NOTES
 # =============================================================================

.gitea/workflows/build-image.yml

@@ -6,6 +6,10 @@ on:
       - 'release/**'
       - 'develop*'
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -23,17 +27,28 @@ jobs:
           if [[ "$BRANCH" == develop* ]]; then
             # Sanitise branch name for tag: replace slashes with dashes
             SAFE_BRANCH=$(echo "$BRANCH" | tr '/' '-')
-            echo "tags=reg.i3omb.com/sofarr:${SAFE_BRANCH}" >> $GITHUB_OUTPUT
-            echo "Building develop image ${SAFE_BRANCH} (version ${VERSION})"
+            TAGS="git.i3omb.com/gandalf/sofarr:${SAFE_BRANCH}"
+            echo "tags=${TAGS}" >> $GITHUB_OUTPUT
+            echo "Building develop image tags: ${TAGS}"
           else
             RELEASE_NAME=${BRANCH#release/}
-            TAGS="reg.i3omb.com/sofarr:${VERSION}"
-            TAGS="${TAGS},reg.i3omb.com/sofarr:${RELEASE_NAME}"
-            TAGS="${TAGS},reg.i3omb.com/sofarr:latest"
+
+            # Gitea package registry tags
+            TAGS="git.i3omb.com/gandalf/sofarr:${VERSION}"
+            TAGS="${TAGS},git.i3omb.com/gandalf/sofarr:${RELEASE_NAME}"
+            TAGS="${TAGS},git.i3omb.com/gandalf/sofarr:latest"
+
             echo "tags=${TAGS}" >> $GITHUB_OUTPUT
-            echo "Building release image ${VERSION} from branch ${BRANCH}"
+            echo "Building release image tags: ${TAGS}"
           fi
 
+      - name: Log into Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.i3omb.com
+          username: ${{ github.actor }}
+          password: ${{ secrets.RELEASE_TOKEN }}
+
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:

.gitea/workflows/ci.yml

@@ -2,9 +2,13 @@ name: CI
 
 on:
   push:
-    branches: ["**"]
+    branches: ["**", "!release/**"]
   pull_request:
-    branches: ["**"]
+    branches: ["**", "!release/**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   audit:
@@ -60,3 +64,54 @@ jobs:
           name: coverage-report
           path: coverage/
           retention-days: 14
+
+  swagger:
+    name: Swagger Validation & Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint OpenAPI spec with Spectral
+        run: npx @stoplight/spectral-cli lint server/openapi.yaml --ruleset .spectral.yml || true
+
+      - name: Run Swagger coverage tests
+        run: npm test -- tests/integration/swagger-coverage.test.js
+        env:
+          DATA_DIR: /tmp/sofarr-ci-data
+          SKIP_RATE_LIMIT: "1"
+          NODE_ENV: test
+
+      - name: Generate merged OpenAPI spec
+        run: npm run generate:openapi
+        env:
+          NODE_ENV: test
+          DATA_DIR: /tmp/sofarr-ci-data
+          SKIP_RATE_LIMIT: "1"
+
+      - name: Convert to RAML
+        run: npm run generate:raml
+        continue-on-error: true
+
+      - name: Package RAML artifact
+        run: npm run package:raml
+        env:
+          GITHUB_SHA: ${{ github.sha }}
+          GITHUB_REF_TYPE: ${{ github.ref_type }}
+          GITHUB_REF_NAME: ${{ github.ref_name }}
+
+      - name: Upload RAML package artifact
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: raml-package
+          path: dist/raml-*.tar.gz
+          retention-days: 14

.gitea/workflows/licence-check.yml

@@ -40,10 +40,21 @@ jobs:
 
       - name: Check licence compatibility
         run: |
-          npx --yes license-checker --production \
-            --onlyAllow "MIT;ISC;MIT-0;BSD-2-Clause;BSD-3-Clause;Apache-2.0;CC0-1.0;BlueOak-1.0.0" \
-            --excludePrivatePackages \
-            && echo "All production dependency licences are compatible with MIT."
+          # First, output all production licenses for visibility
+          echo "Checking production dependency licenses..."
+          npx --yes license-checker --production --excludePrivatePackages --json > /tmp/licenses.json
+          
+          # Check for incompatible licenses
+          if ! npx --yes license-checker --production \
+            --onlyAllow "MIT;ISC;MIT-0;BSD-2-Clause;BSD-3-Clause;Apache-2.0;CC0-1.0;BlueOak-1.0.0;Python-2.0" \
+            --excludePrivatePackages; then
+            echo ""
+            echo "❌ Found incompatible licenses. Full license report:"
+            cat /tmp/licenses.json
+            exit 1
+          fi
+          
+          echo "✅ All production dependency licences are compatible with MIT."
 
       - name: Check copyright headers in source files
         run: |
@@ -56,6 +67,7 @@ jobs:
             ! -path "./.git/*" \
             ! -path "./dist/*" \
             ! -path "./build/*" \
+            ! -path "./public/*" \
             ! -path "./.gitea/*")
           
           MISSING_HEADER=0
@@ -70,6 +82,9 @@ jobs:
             if ! head -n 5 "$file" | grep -qiE "Copyright.*[0-9]{4}.*MIT"; then
               echo "❌ Missing MIT-compliant copyright header in: $file"
               echo "   Required format: // Copyright (c) YYYY Name. MIT License."
+              echo "   Actual first 5 lines:"
+              head -n 5 "$file" | sed 's/^/     /'
+              echo ""
               MISSING_HEADER=$((MISSING_HEADER + 1))
             fi
           done <<< "$SOURCE_FILES"

.gitignore

@@ -10,3 +10,6 @@ data/
 *.db
 *.db-wal
 *.db-shm
+.agents/
+.windsurf/
+scratch/

.spectral.yml

@@ -0,0 +1,10 @@
+extends: spectral:oas
+rules:
+  # Ensure all operations have descriptions
+  operation-description: warn
+  # Ensure all paths have parameters defined
+  path-params-defined: error
+  # Ensure all schemas have examples where appropriate
+  example-provided: warn
+  # Disable rules that are too strict for this project
+  operation-operationId: off

ARCHITECTURE.md

@@ -37,6 +37,7 @@ Three pluggable layers form the architectural core:
 |-------|------|----------|
 | Download client abstraction | **PDCA** — Pluggable Download Client Architecture | `server/clients/` + `server/utils/downloadClients.js` |
 | *arr data retrieval | **PALDRA** — Pluggable *Arr Library Data Retrieval Architecture | `server/utils/arrRetrievers.js` |
+| Download matching & assembly | **Download Services** | `server/services/` |
 | Real-time push | **Webhook Receiver** | `server/routes/webhook.js` |
 
 ---
@@ -50,6 +51,9 @@ flowchart TB
         dash["Dashboard Cards"]
         status["Status Panel\n(Admin only)"]
         history["History Tab"]
+        requests["Requests Tab\n+ Filters / Search"]
+        webhooks["Webhook Config"]
+        swagger["Swagger UI\n/api/swagger"]
     end
 
     subgraph Server["Express Server (:3001)"]
@@ -57,7 +61,9 @@ flowchart TB
         mw["Middleware\nHelmet · rate-limit · cookie-parser · verifyCsrf"]
         auth_r["Auth Routes\n/api/auth"]
         dash_r["Dashboard Routes\n/api/dashboard  (SSE /stream)"]
-        wh_r["Webhook Routes\n/api/webhook/sonarr|radarr"]
+        stat_r["Status Routes\n/api/status"]
+        wh_r["Webhook Routes\n/api/webhook/sonarr|radarr|ombi"]
+        ombi_r["Ombi Routes\n/api/ombi"]
         hist_r["History Routes\n/api/history"]
         proxy_r["Proxy Routes\n/api/sonarr · /api/radarr\n/api/sabnzbd · /api/emby"]
 
@@ -78,27 +84,31 @@ flowchart TB
         rtorrent["rTorrent"]
         transmission["Transmission"]
         emby["Emby / Jellyfin"]
+        ombi["Ombi"]
     end
 
     login -->|"POST /api/auth/login"| auth_r
     dash  -->|"GET /api/dashboard/stream (SSE)"| dash_r
-    status -->|"GET /api/dashboard/status"| dash_r
+    status -->|"GET /api/status"| stat_r
     history -->|"GET /api/history/recent"| hist_r
+    requests -->|"GET /api/ombi/requests"| ombi_r
 
     auth_r --> tokenstore
     auth_r -->|"authenticate"| emby
 
     dash_r --> cache
     dash_r --> poller
+    stat_r --> cache
     wh_r --> cache
     wh_r --> paldra
+    ombi_r --> paldra
     hist_r --> cache
     proxy_r -->|"proxy"| sonarr & radarr & sab & emby
 
     poller --> pdca & paldra
     poller --> cache
     pdca -->|"HTTP/API"| sab & qbt & rtorrent & transmission
-    paldra -->|"HTTP/API"| sonarr & radarr
+    paldra -->|"HTTP/API"| sonarr & radarr & ombi
 
     sonarr & radarr -->|"POST /api/webhook/*"| wh_r
 ```
@@ -109,7 +119,7 @@ flowchart TB
 Browser (SPA)
     │  POST /api/auth/login          → Auth routes → Emby verify → set httpOnly cookie
     │  GET  /api/dashboard/stream    → SSE stream → cache → matched downloads
-    │  POST /api/webhook/*           ← Sonarr/Radarr push events
+    │  POST /api/webhook/*           ← Sonarr/Radarr/Ombi push events
     │
     ▼
 Express Server (:3001)
@@ -118,13 +128,18 @@ Express Server (:3001)
     ├── cookie-parser (HMAC-signed session cookie)
     ├── verifyCsrf (double-submit cookie, all state-changing /api routes except auth + webhook)
     │
+    ├── /api/swagger       → Swagger UI (public, auth banner for testing)
     ├── /api/auth          → login, logout, me, csrf
     ├── /api/webhook       → [rate-limit] → [secret validation] → [payload validation]
     │                        → [replay check] → updateWebhookMetrics → processWebhookEvent
-    ├── /api/dashboard     → requireAuth → read cache → match downloads → SSE/JSON
-    ├── /api/history       → requireAuth → historyFetcher (5 min cache) → filter + dedup
-    ├── /api/sonarr|radarr → requireAuth → verifyCsrf → proxy to *arr API
-    └── /api/sabnzbd|emby  → requireAuth → verifyCsrf → proxy
+    │                        → /config: GET endpoint for configuration status validation
+    ├── /api/dashboard     → requireAuth → read cache → DownloadBuilder → SSE/JSON
+    ├── /api/status          → requireAuth → admin cache/polling/webhook status
+    ├── /api/history         → requireAuth → historyFetcher (5 min cache) → filter + dedup
+    ├── /api/ombi            → requireAuth → PALDRA → filter/sort/search → JSON
+    │                        → /webhook/*: enable (POST), status (GET), and test (POST) endpoints
+    ├── /api/sonarr|radarr   → requireAuth → verifyCsrf → proxy to *arr API
+    └── /api/sabnzbd|emby    → requireAuth → verifyCsrf → proxy
 
 Background:
     Poller (setInterval POLL_INTERVAL ms)
@@ -239,7 +254,7 @@ Each `QBittorrentClient` instance maintains:
 
 Per-cycle flow:
 1. Attempt `GET /api/v2/sync/maindata?rid={lastRid}`.
-2. If `full_update` is `true`, rebuild `torrentMap` from scratch.
+2. If `full_update` is `true`, rebuild `torrentMap` from scratch (resets incremental state to prevent corruption).
 3. Otherwise merge delta fields into existing entries; remove `torrents_removed` hashes.
 4. On Sync API failure, fall back **once per cycle** to `GET /api/v2/torrents/info`.
 5. If the fallback also fails, return an empty array for this cycle and log the error.
@@ -258,10 +273,19 @@ The rest of the application (poller, dashboard) receives data in the same format
 
 #### Overview
 
-`server/utils/arrRetrievers.js` exports `arrRetrieverRegistry`, a singleton that manages one `PollingSonarrRetriever` or `PollingRadarrRetriever` per configured instance. It provides a uniform interface for fetching queue, history, and tag data, keyed by service type.
+`server/utils/arrRetrievers.js` exports `arrRetrieverRegistry`, a singleton that manages one `PollingSonarrRetriever`, `PollingRadarrRetriever`, or `OmbiRetriever` per configured instance. It provides a uniform interface for fetching queue, history, and tag data, keyed by service type.
 
 The registry is used by both the background poller and the webhook processor, guaranteeing consistent data shapes across both update paths.
 
+**Supported Retrievers:**
+- **PollingSonarrRetriever**: TV series data from Sonarr instances
+- **PollingRadarrRetriever**: Movie data from Radarr instances
+- **OmbiRetriever**: Request management data from Ombi instances
+
+#### Error handling
+
+Retriever methods now throw on HTTP failure rather than swallowing errors silently. This ensures the poller logs upstream problems and skips the affected instance cleanly instead of caching stale empty data.
+
 #### Registry API
 
 ```javascript
@@ -269,15 +293,32 @@ arrRetrieverRegistry = {
   async initialize()                              // idempotent; reads config once
   getAllRetrievers(): ArrRetriever[]
   getRetriever(instanceId): ArrRetriever | null
-  getRetrieversByType(type): ArrRetriever[]       // 'sonarr' | 'radarr'
+  getRetrieversByType(type): ArrRetriever[]       // 'sonarr' | 'radarr' | 'ombi'
 
   // Typed fetch methods — all return { sonarr: [...], radarr: [...] }
   async getQueuesByType(): Promise<{ sonarr, radarr }>
   async getHistoryByType(options?): Promise<{ sonarr, radarr }>
   async getTagsByType(): Promise<{ sonarr, radarr }>
+
+  // Ombi-specific methods
+  getOmbiRetrievers(): OmbiRetriever[]
+  async getOmbiRequests(): Promise<{ movie: [], tv: [] }>
+  async getOmbiRequestsByType(): Promise<{ movie: [], tv: [] }>
+  async findOmbiRequest(type, externalIds): Promise<Object | null>
 }
 ```
 
+#### Ombi retriever
+
+The `OmbiRetriever` (in `server/clients/OmbiClient.js`) fetches from:
+
+| Task | Endpoint | Notes |
+|------|----------|-------|
+| Movie requests | `GET /api/v1/Request/movie` | Returns full movie request objects |
+| TV requests | `GET /api/v1/Request/tv` | Returns full TV request objects |
+
+Results are cached under `poll:ombi` and broadcast via SSE as `ombiRequests: { movie, tv }`. The client applies the same `ombiFilters.js` logic used by the server route, keeping behaviour consistent across both layers.
+
 Each result element is `{ instance: instanceId, data: <arr API response> }`, allowing callers to look up instance credentials from `config.js`.
 
 #### Retriever API Calls
@@ -285,13 +326,55 @@ Each result element is `{ instance: instanceId, data: <arr API response> }`, all
 | Task | Endpoint | Key Parameters |
 |------|----------|----------------|
 | Sonarr tags | `GET /api/v3/tag` | — |
-| Sonarr queue | `GET /api/v3/queue` | `includeSeries=true`, `includeEpisode=true` |
-| Sonarr history | `GET /api/v3/history` | `pageSize=10`, `includeEpisode=true` |
+| Sonarr queue | `GET /api/v3/queue` | `includeSeries=true`, `includeEpisode=true`, `pageSize=1000` (paginated up to 50 pages) |
+| Sonarr history | `GET /api/v3/history` | `pageSize=50` (poller), `maxPages=1` (default), `includeEpisode=true` |
 | Radarr tags | `GET /api/v3/tag` | — |
-| Radarr queue | `GET /api/v3/queue` | `includeMovie=true` |
-| Radarr history | `GET /api/v3/history` | `pageSize=10` |
+| Radarr queue | `GET /api/v3/queue` | `includeMovie=true`, `pageSize=1000` (paginated up to 50 pages) |
+| Radarr history | `GET /api/v3/history` | `pageSize=50` (poller), `maxPages=1` (default) |
 
-All fetches across all instances run in parallel via `Promise.allSettled`, so a single failing instance does not block others.
+All fetches across all instances run in parallel via `Promise.allSettled`, so a single failing instance does not block others. Queue fetches automatically paginate through all available records; history fetches default to a single page to avoid multi-second response times, while the UI history fetcher uses 100 records per page.
+
+### 3.3 Download Matching & Assembly Services
+
+#### Overview
+
+The `server/services/` directory contains pure, testable services that transform raw cache data into user-facing download objects. These were extracted from `dashboard.js` during the technical-debt remediation, reducing the route file from ~1,360 lines to ~284 lines.
+
+#### Service hierarchy
+
+```
+DownloadBuilder.js          Orchestrator: reads cache snapshot, calls matchers, deduplicates results
+├── DownloadMatcher.js      Matches SABnzbd slots and qBittorrent torrents to Sonarr/Radarr records
+│   ├── matchSabSlots()     Queue slots: matches by downloadId first, then bidirectional title substring
+│   ├── matchSabHistory()   History slots: title matching against Sonarr/Radarr history
+│   └── matchTorrents()     Torrents: queue → history fallback; unmatched torrents are excluded
+├── DownloadAssembler.js    Pure helpers for building download objects
+│   ├── getCoverArt()       Poster/fanart resolution
+│   ├── getImportIssues()   Warning/error message extraction
+│   ├── getSonarrLink() / getRadarrLink()
+│   ├── canBlocklist()      Admin vs non-admin blocklist eligibility
+│   ├── extractEpisode()    Season/episode/title from queue/history record
+│   └── gatherEpisodes()    Collect all episodes sharing the same download title
+└── TagMatcher.js           Tag extraction, sanitisation, and user matching
+    ├── extractAllTags() / extractUserTag()
+    ├── tagMatchesUser()    Exact or sanitised match (handles Ombi-mangled tags)
+    ├── getEmbyUsers()      Cached Emby user Map (60 s TTL)
+    └── buildTagBadges()    Classify tags for admin showAll view
+```
+
+#### Matching priority
+
+For each download item, the matcher attempts matches in priority order:
+
+1. **Stable ID match** — `downloadId` on SABnzbd slots is compared against Sonarr/Radarr queue/history `downloadId` fields (most reliable).
+2. **Title substring match** — bidirectional, case-insensitive substring check between the download name and the *arr `title` / `sourceTitle`.
+3. **Normalised title match** — dots replaced with spaces to handle release-name vs display-title mismatches.
+
+Unmatched torrents are **not** included in the response (fixed in develop-refactor2).
+
+#### Deduplication
+
+`DownloadBuilder.buildUserDownloads()` deduplicates by `${type}:${title}` so the same download does not appear twice when it is present in both queue and history.
 
 ---
 
@@ -299,19 +382,20 @@ All fetches across all instances run in parallel via `Promise.allSettled`, so a
 
 ### 4.1 Webhook Receiver
 
-sofarr exposes two webhook endpoints that Sonarr and Radarr can be configured to call on every automation event:
+sofarr exposes three webhook endpoints that Sonarr, Radarr, and Ombi can be configured to call on automation and request events:
 
 ```
 POST /api/webhook/sonarr
 POST /api/webhook/radarr
+POST /api/webhook/ombi
 ```
 
 Both endpoints share identical processing logic:
 
 ```
-Sonarr/Radarr
+Sonarr/Radarr/Ombi
     POST /api/webhook/sonarr
-    Headers: X-Sofarr-Webhook-Secret: <secret>
+    Headers: X-Sofarr-Webhook-Secret: <secret> OR URL parameter: ?secret=<secret>
     Body:    { "eventType": "Grab", "instanceName": "Main Sonarr",
                "date": "2026-05-19T10:00:00.000Z", … }
         │
@@ -320,6 +404,7 @@ Sonarr/Radarr
         │
         ▼
     validateWebhookSecret()  ──fail──► 401 Unauthorized
+        (Checks header or query param)
         │ ok
         ▼
     validatePayload()        ──fail──► 400 Bad Request
@@ -341,6 +426,10 @@ Sonarr/Radarr
         └── pollAllServices() → pollSubscribers.forEach(cb) → SSE push
 ```
 
+#### Replay protection improvements
+
+The replay cache uses an atomic `Set`-based deduplication key (`{eventType}:{instanceName}:{date}`) with a 5-minute TTL. `instanceName` precision was tightened so that events from different *arr instances are never incorrectly flagged as duplicates.
+
 The 200 response is sent **before** the background cache refresh completes, ensuring Sonarr/Radarr never have to wait for sofarr's downstream API calls.
 
 #### Event Classification
@@ -383,6 +472,8 @@ The dashboard therefore receives fresh data within the round-trip time of the *a
 
 The `sonarr.js` and `radarr.js` route modules expose endpoints (under `/api/sonarr` and `/api/radarr` respectively, behind `requireAuth` + `verifyCsrf`) for one-click webhook configuration. These proxy to the *arr notification API to create, update, or remove the sofarr webhook connection in Sonarr/Radarr, using `SOFARR_BASE_URL` to construct the target URL.
 
+Similarly, the `ombi.js` route module exposes endpoints under `/api/ombi/webhook/` (including `/enable`, `/status`, and `/test`) to support one-click registration and validation of the Sofarr webhook inside the configured Ombi instance.
+
 ---
 
 ## 5. Data Flow and Real-time Updates
@@ -397,10 +488,10 @@ Every `POLL_INTERVAL` ms the poller fetches all services in parallel:
 | SABnzbd History | `GET /api?mode=history` | `limit=10` |
 | Sonarr Tags | `GET /api/v3/tag` | — |
 | Sonarr Queue | `GET /api/v3/queue` | `includeSeries=true`, `includeEpisode=true` |
-| Sonarr History | `GET /api/v3/history` | `pageSize=10`, `includeEpisode=true` |
+| Sonarr History | `GET /api/v3/history` | `pageSize=50`, `includeEpisode=true` |
 | Radarr Tags | `GET /api/v3/tag` | — |
 | Radarr Queue | `GET /api/v3/queue` | `includeMovie=true` |
-| Radarr History | `GET /api/v3/history` | `pageSize=10` |
+| Radarr History | `GET /api/v3/history` | `pageSize=50` |
 | qBittorrent | `GET /api/v2/sync/maindata?rid=N` | Fallback: `GET /api/v2/torrents/info` |
 
 Results are stored in `MemoryCache` under `poll:*` keys with TTL `POLL_INTERVAL × 3`. Per-task timings are recorded in `lastPollTimings` for the admin status panel.
@@ -460,31 +551,62 @@ When a browser opens `GET /api/dashboard/stream`:
 
 The browser's native `EventSource` API handles reconnection automatically on network interruption.
 
+**SSE Payload Structure**
+
+```javascript
+{
+  user: string,              // Username
+  isAdmin: boolean,          // Admin flag
+  downloads: DownloadObject[],  // Matched download objects (see Section 5.4)
+  downloadClients: {         // Configured download clients for ordering/filtering
+    id: string,              // Instance identifier
+    name: string,            // Instance display name
+    type: string             // Client type ('sabnzbd', 'qbittorrent', 'transmission', 'rtorrent')
+  }[],
+  ombiRequests: {            // Raw Ombi movie + TV requests (client applies filters)
+    movie: OmbiRequest[],
+    tv: OmbiRequest[]
+  },
+  ombiBaseUrl: string         // Ombi instance base URL for deep links
+}
+```
+
 ### 5.4 Download Matching Pipeline
 
 For each connected user the server:
 
 1. Reads all `poll:*` keys from `MemoryCache`.
 2. Builds `seriesMap`, `moviesMap`, `sonarrTagMap`, and `radarrTagMap` from embedded objects in queue records.
-3. For each SABnzbd/qBittorrent download item, attempts matches in priority order: Sonarr queue → Radarr queue → Sonarr history → Radarr history.
-4. Title matching is a **bidirectional, case-insensitive substring match**: `rTitle.includes(dlTitle) || dlTitle.includes(rTitle)`.
-5. For each match, resolves the series/movie, extracts user tags, checks ownership.
-6. Returns only the requesting user's downloads (or all, if admin with `showAll=true`).
+3. Delegates to `DownloadBuilder.buildUserDownloads(cacheSnapshot, options)`, which orchestrates:
+   - `DownloadMatcher.matchSabSlots()` — matches active SABnzbd queue slots
+   - `DownloadMatcher.matchSabHistory()` — matches recent SABnzbd history slots
+   - `DownloadMatcher.matchTorrents()` — matches qBittorrent torrents
+4. Each matcher attempts matches in priority order:
+   - **Stable ID match** — `downloadId` compared against *arr `downloadId` (most reliable).
+   - **Bidirectional title substring match** — case-insensitive `rTitle.includes(dlTitle) || dlTitle.includes(rTitle)`.
+   - **Normalised title match** — dots replaced with spaces for release-name vs display-title mismatches.
+5. Unmatched torrents are excluded; matched results are deduplicated by `${type}:${title}`.
+6. For each match, `DownloadAssembler` resolves cover art, episodes, import issues, blocklist eligibility, and admin fields.
+7. `TagMatcher` extracts user tags and checks ownership.
+8. Returns only the requesting user's downloads (or all, if admin with `showAll=true`).
 
 ```mermaid
 flowchart TD
-    Start(["Download item"]) --> SQ{"Sonarr QUEUE\nmatch (title)"}
+    Start(["Download item"]) --> DLID{"Stable ID match\ndownloadId?"}
+    DLID -->|yes| IDResolve["Resolve series/movie\nfrom queue/history record"]
+    DLID -->|no| SQ{"Sonarr QUEUE\ntitle match?"}
     SQ -->|yes| SQR["Resolve series · extract user tag"]
-    SQ -->|no| RQ{"Radarr QUEUE\nmatch (title)"}
+    SQ -->|no| RQ{"Radarr QUEUE\ntitle match?"}
     RQ -->|yes| RQR["Resolve movie · extract user tag"]
-    RQ -->|no| SH{"Sonarr HISTORY\nmatch (title)"}
+    RQ -->|no| SH{"Sonarr HISTORY\ntitle match?"}
     SH -->|yes| SHR["Resolve series via seriesId"]
-    SH -->|no| RH{"Radarr HISTORY\nmatch (title)"}
+    SH -->|no| RH{"Radarr HISTORY\ntitle match?"}
     RH -->|yes| RHR["Resolve movie via movieId"]
     RH -->|no| Skip(["Skip — unmatched"])
 
-    SQR & RQR & SHR & RHR --> Tagged{"Tag matches\nrequesting user?"}
-    Tagged -->|yes| Include(["Include in response"])
+    IDResolve & SQR & RQR & SHR & RHR --> Tagged{"Tag matches\nrequesting user?"}
+    Tagged -->|yes| Dedup["Deduplicate by type:title"]
+    Dedup --> Include(["Include in response"])
     Tagged -->|no| Skip
 ```
 
@@ -495,6 +617,14 @@ Users are matched to downloads via Sonarr/Radarr tags:
 1. **Exact match** — tag label (lowercased) === username (lowercased).
 2. **Sanitised match** — handles Ombi tag mangling: `sanitizeTagLabel()` converts to lowercase, replaces non-alphanumeric chars with hyphens, collapses runs, trims.
 
+#### Client ordering and filtering
+
+Matched download objects include `client`, `instanceId`, and `instanceName` fields. The frontend:
+1. Receives a `downloadClients` array from the SSE payload with all configured clients in configuration order
+2. Displays a multi-select filter allowing users to choose which clients to view
+3. Sorts downloads by client order (downloads from the first configured client appear first)
+4. Filters downloads to show only those from selected client instances
+
 #### Matched download object fields
 
 | Field | Type | Description |
@@ -523,9 +653,73 @@ Users are matched to downloads via Sonarr/Radarr tags:
 | `arrInstanceKey` | string/null | (Admin) API key for the *arr instance |
 | `arrContentId` | number/null | (Admin) `episodeId` or `movieId` for triggering a new search |
 | `arrContentType` | `'episode'`/`'movie'`/null | (Admin) Content type for search command |
+| `client` | string | Download client type ('sabnzbd', 'qbittorrent', 'transmission', 'rtorrent') |
+| `instanceId` | string | Instance identifier matching the configured client ID |
+| `instanceName` | string | Instance display name from configuration |
 | `addedOn` | number/null | (qBittorrent) Unix timestamp when torrent was added |
 | `availableForUpgrade` | boolean/undefined | (History) `true` when outcome is `failed` but content is on disk |
 
+### 5.5 Ombi Request Filtering
+
+The Ombi Requests tab displays movie and TV requests from Ombi. Filtering, sorting, and text search are applied **server-side** on the REST endpoint (`GET /api/ombi/requests`) and **client-side** on every SSE update. This dual-layer approach ensures external API consumers receive pre-filtered data while the SPA remains responsive without extra round-trips.
+
+```mermaid
+sequenceDiagram
+    participant Client as Browser (Requests Tab)
+    participant SSE as SSE /api/dashboard/stream
+    participant Route as /api/ombi/requests
+    participant Filters as ombiFilters (shared)
+    participant PALDRA as PALDRA Registry
+    participant Ombi as Ombi API
+
+    Note over Client: Initial load
+    Client->>Route: GET /api/ombi/requests?type=…&status=…&sort=…&search=…
+    Route->>PALDRA: getOmbiRequests()
+    PALDRA->>Ombi: GET /api/v1/Request/movie + /tv
+    Ombi-->>PALDRA: raw request arrays
+    PALDRA-->>Route: { movie: [], tv: [] }
+    Route->>Filters: applyRequestFilters()
+    Filters-->>Route: filtered & sorted requests
+    Route-->>Client: { requests: { movie, tv }, total }
+
+    Note over Client: Real-time updates
+    SSE->>Client: push raw ombiRequests + ombiBaseUrl
+    Client->>Filters: applyRequestFilters() (same code)
+    Filters-->>Client: filtered & sorted requests
+    Client->>Client: renderRequests()
+```
+
+#### Query parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `type` | `movie` \| `tv` \| `all` | `all` | Media type filter (multi-select) |
+| `status` | `pending` \| `approved` \| `available` \| `denied` | — | Request status filter (multi-select) |
+| `sort` | `requestedDate_desc` \| `requestedDate_asc` \| `title_asc` \| `title_desc` | `requestedDate_desc` | Sort mode |
+| `search` | string | — | Case-insensitive title substring |
+| `showAll` | `'true'` \| `'false'` | `'false'` | Admin only: show all users' requests |
+
+#### Status priority
+
+The same `getRequestStatus()` function runs on both server and client:
+
+1. `available` — if `available === true`
+2. `denied` — if `denied === true`
+3. `approved` — if `approved === true`
+4. `pending` — if `requested === true`
+5. `unknown` — fallback
+
+#### Persistence
+
+Filter and sort preferences are persisted in `localStorage` under the following keys:
+
+| Key | Content |
+|-----|---------|
+| `sofarr-request-types` | `['movie', 'tv']` or subset |
+| `sofarr-request-statuses` | `['pending', 'approved', 'available', 'denied']` or subset |
+| `sofarr-request-sort` | `requestedDate_desc`, `requestedDate_asc`, `title_asc`, `title_desc` |
+| `sofarr-request-search` | Free-text query string |
+
 ---
 
 ## 6. Caching and Smart Polling
@@ -562,6 +756,7 @@ class MemoryCache {
 | `poll:radarr-history` | `{ records }` — lightweight | `POLL_INTERVAL × 3` |
 | `poll:radarr-tags` | `[{ instance, data: [{id, label}] }]` | `POLL_INTERVAL × 3` |
 | `poll:qbittorrent` | `[torrent, …]` | `POLL_INTERVAL × 3` |
+| `poll:ombi` | `{ movie: [], tv: [] }` | `POLL_INTERVAL × 3` |
 | `history:sonarr` | `[record, …]` flat array with `_instanceUrl`/`_instanceName` | 5 min |
 | `history:radarr` | `[record, …]` flat array with `_instanceUrl`/`_instanceName` | 5 min |
 | `emby:users` | `Map<lowerName, displayName>` | 60 s |
@@ -616,8 +811,8 @@ See [Section 3.1](#31-pluggable-download-client-architecture-pdca) for full deta
 
 ```
 DownloadClient (abstract — server/clients/DownloadClient.js)
-├── SABnzbdClient.js       — Usenet; REST; API key auth
-├── QBittorrentClient.js   — Torrent; Sync API + fallback; cookie auth
+├── SABnzbdClient.js       — Usenet; REST; API key auth; fixed global-speed assignment
+├── QBittorrentClient.js   — Torrent; Sync API + fallback; cookie auth; full-sync corruption fix
 ├── TransmissionClient.js  — Torrent; JSON-RPC; session-ID management
 └── RTorrentClient.js      — Torrent; XML-RPC; HTTP Basic Auth
 ```
@@ -626,7 +821,9 @@ DownloadClient (abstract — server/clients/DownloadClient.js)
 
 ### 7.2 Queue & History Processing
 
-**`server/utils/historyFetcher.js`** fetches history records from all Sonarr/Radarr instances for a configurable date window. Results are cached under `history:sonarr` / `history:radarr` for 5 minutes. Exports `classifySonarrEvent` / `classifyRadarrEvent` (returns `'imported'` | `'failed'` | `'other'`) and `invalidateHistoryCache`.
+**`server/utils/historyFetcher.js`** fetches history records from all Sonarr/Radarr instances for a configurable date window. Results are cached under `history:sonarr` / `history:radarr` for 5 minutes. Exports `classifySonarrEvent` / `classifyRadarrEvent` (returns `'imported'` | `'failed'` | `'other'`), `invalidateHistoryCache`, and `onHistoryUpdate` / `emitHistoryUpdate` for SSE staging.
+
+**Staged loading** — the fetcher returns up to `INITIAL_PAGE_SIZE` (100) records immediately from the cache or a quick fetch. If fewer than `MAX_TOTAL_RECORDS` (1,000) are present, a background fetch of up to `MAX_PAGES` (10) is triggered automatically. As the background fetch completes, `emitHistoryUpdate()` notifies all registered subscribers, which causes the SSE layer to push a `history-update` frame to every connected browser. The frontend (`client/src/ui/history.js`) listens for these events and re-renders the "Recently Completed" tab incrementally.
 
 **`server/routes/history.js`** (`GET /api/history/recent`) returns recently completed (imported or failed) downloads filtered for the authenticated user. Supports `?days=N` (default `RECENT_COMPLETED_DAYS`, capped at 90) and `?showAll=true` for admins. Results are sorted newest first.
 
@@ -634,12 +831,34 @@ DownloadClient (abstract — server/clients/DownloadClient.js)
 
 ### 7.3 Dashboard & Frontend
 
-The frontend is a **vanilla JavaScript SPA** with no build step. All logic resides in `public/app.js`, styled by `public/style.css`, and structured by `public/index.html`. Three CSS themes are available via the `data-theme` attribute on `<html>` and persist in `localStorage`:
+The frontend is a **vanilla JavaScript SPA** built from ES modules in `client/src/` and bundled by **Vite** into `public/app.js`. Three CSS themes are available via the `data-theme` attribute on `<html>` and persist in `localStorage`:
 
 - **Light** — Purple gradient header, white cards
 - **Dark** — Dark surfaces, muted accents
 - **Mono** — Monochrome, minimal colour
 
+#### Module structure
+
+```
+client/src/
+├── main.js              Bootstrap: DOMContentLoaded → init theme, auth check
+├── state.js             Global reactive state object
+├── api.js               All HTTP fetch wrappers (+ CSRF handling)
+├── sse.js               EventSource lifecycle, reconnect, heartbeat
+├── ui/
+│   ├── auth.js          Login/logout form handlers
+│   ├── downloads.js     Card rendering, create/update helpers, client-logo helpers
+│   ├── filters.js       Download-client multi-select filter
+│   ├── history.js       History tab: fetch, render, ignoreAvailable toggle
+│   ├── statusPanel.js   Admin status panel (server, polling, cache, webhooks)
+│   ├── tabs.js          Tab navigation (data-tab attributes)
+│   ├── theme.js         Light/Dark/Mono theme switcher
+│   └── webhooks.js      One-click Sonarr/Radarr webhook configuration
+└── utils/
+    ├── format.js        Size, speed, duration, percentage formatters
+    └── storage.js       localStorage wrappers with JSON parsing
+```
+
 #### UI state machine
 
 ```mermaid
@@ -675,28 +894,142 @@ stateDiagram-v2
     }
 ```
 
-#### Key frontend functions
+#### Key frontend modules
 
-| Function | Purpose |
-|----------|---------|
-| `checkAuthentication()` | On load: check session → show dashboard or login |
-| `handleLogin()` | Authenticate, fade login → splash → dashboard |
-| `startSSE()` | Open `EventSource` to `/stream`; handle incoming data |
-| `stopSSE()` | Close `EventSource` and cancel reconnect timer |
-| `renderDownloads()` | Diff-based card rendering (create/update/remove) |
-| `createDownloadCard()` | Build DOM for a single card; renders tag badges, import-issue badge, blocklist button |
-| `updateDownloadCard()` | Update existing card in-place (progress, speed, etc.) |
-| `handleBlocklistSearch()` | Confirm dialog → POST `/blocklist-search` → update button state |
-| `toggleStatusPanel()` | Show/hide admin status panel |
-| `renderStatusPanel()` | Build status HTML (server, polling, SSE clients, cache) |
-| `initThemeSwitcher()` | Light / Dark / Mono theme support |
-| `loadHistory()` | Fetch `/api/history/recent`, store raw items, call `renderHistory()` |
-| `renderHistory()` | Filter items by `ignoreAvailable` flag, render history cards |
+| Module / Function | Purpose |
+|-------------------|---------|
+| `auth.js` | `checkAuthentication()`, `handleLogin()`, `handleLogout()` |
+| `sse.js` | `startSSE()`, `stopSSE()` — EventSource lifecycle and auto-reconnect |
+| `downloads.js` | `renderDownloads()`, `createDownloadCard()`, `updateDownloadCard()` — diff-based DOM; client-logo and tag-badge helpers deduplicated |
+| `filters.js` | `initDownloadClientFilter()` — multi-select dropdown, Select/Deselect All, localStorage persistence |
+| `history.js` | `loadHistory()`, `renderHistory()` — filter by `ignoreAvailable`, render cards |
+| `statusPanel.js` | `toggleStatusPanel()`, `renderStatusPanel()` — admin server/polling/cache/webhook status |
+| `theme.js` | `initThemeSwitcher()` — Light / Dark / Mono theme support |
+| `webhooks.js` | One-click Sonarr/Radarr webhook configuration via proxy API |
+| `format.js` | Size, speed, duration, percentage formatters (24 unit tests) |
+| `storage.js` | localStorage wrappers with JSON parsing and error handling |
 
-#### Tag badge rendering
+#### CSP compliance
 
-- **Regular user view** — a single accent-coloured badge showing the tag label that matched the current user's username (via `matchedUserTag`).
-- **Admin `showAll` view** — all tags on the download are rendered using `tagBadges[]`: tags with no matching Emby user → amber badge (leftmost); tags matched to a known Emby user → accent badge showing the Emby display name (rightmost).
+All UI modules use CSS class toggling (`.hidden`) instead of inline `style.display` to comply with the strict Content-Security-Policy enforced by Helmet.
+
+#### Download Client Filter
+
+The Active Downloads tab includes a multi-select dropdown filter that allows users to:
+- View all download clients with their type displayed as "Client Name (type)"
+- Select multiple clients to filter the downloads list
+- Use "Select All" / "Deselect All" buttons for bulk operations
+- Persist selection across sessions via localStorage
+
+Related functions in `filters.js`:
+- `initDownloadClientFilter()` — Sets up dropdown toggle, click-outside handler, Select/Deselect All buttons
+- `updateDownloadClientFilter()` — Populates checkbox list with client name + type badges
+- `toggleClientSelection()` — Updates selection array and localStorage
+- `updateSelectedCountDisplay()` — Updates button text to show "All clients" / "1 selected" / "N selected"
+
+Downloads are sorted by client order (matching the configuration order) and filtered by the selected client IDs.
+
+### 7.4 API Documentation System
+
+sofarr exposes interactive API documentation via **Swagger UI** at `/api/swagger`, using a hybrid documentation model that balances maintainability with consistency.
+
+#### Architecture
+
+```
+server/openapi.yaml           Central spec: base metadata, security schemes, reusable schemas
+    │
+    │  merge at runtime (swagger-jsdoc)
+    ▼
+server/routes/*.js            JSDoc @openapi comments per endpoint
+    │
+    │  serve (swagger-ui-express)
+    ▼
+GET /api/swagger              Swagger UI HTML (public, auth banner)
+GET /api/swagger.json         Merged OpenAPI 3.1 spec JSON
+```
+
+#### Central OpenAPI Specification (`server/openapi.yaml`)
+
+The YAML file defines:
+- **Base metadata** — `openapi: 3.1.0`, info, server URL, contact
+- **Security schemes** — `CookieAuth` (`emby_user` cookie), `CsrfToken` (`X-CSRF-Token` header)
+- **Component schemas** — `NormalizedDownload`, `DashboardPayload`, `ErrorResponse`, `BlocklistSearchRequest`, `WebhookPayload`, `HistoryItem`, `StatusResponse`
+- **Path placeholders** — stub entries for every endpoint so JSDoc comments have a merge target
+
+#### JSDoc `@openapi` Comments
+
+Every route handler file contains JSDoc comments above each Express route definition:
+
+```javascript
+/**
+ * @openapi
+ * /api/auth/login:
+ *   post:
+ *     tags: [Authentication]
+ *     summary: Authenticate with Emby
+ *     ...
+ */
+router.post('/login', ...)
+```
+
+`swagger-jsdoc` scans `server/routes/**/*.js` and merges the YAML from these comments into the central spec at runtime.
+
+#### Machine-Usable Extensions
+
+For AI agents and automated tooling, every endpoint includes:
+- **`x-code-samples`** — cURL, JavaScript fetch, and TypeScript examples
+- **`x-integration-notes`** — Human-readable integration guidance embedded in descriptions
+
+#### Coverage Validation
+
+`tests/integration/swagger-coverage.test.js` (22 tests) validates:
+- The YAML spec parses without errors
+- Every Express route appears in the merged spec
+- All examples are valid JSON
+- Security schemes are correctly referenced (`CookieAuth`, `CsrfToken`)
+- The Swagger UI endpoint returns `200`
+
+#### CI/CD Integration
+
+`.gitea/workflows/ci.yml` includes a "Swagger Validation & Coverage" job that:
+- Lints `server/openapi.yaml` with `@stoplight/spectral-cli`
+- Runs the coverage test suite on every push
+
+### 7.5 Real-Time Debug Log Streaming Subsystem
+
+sofarr provides a togglable, real-time log capturing and streaming engine allowing developer-administrators to view server standard output stream activity and browser console log activity for easy debugging in production.
+
+#### Architecture
+
+```mermaid
+flowchart LR
+    subgraph Browser ["Browser (SPA)"]
+        console["console.log/warn/error"] --> queue["logQueue (batched)"]
+        queue --> |POST /api/debug/client-logs| ingestionRoute["POST router handler"]
+    end
+
+    subgraph Server ["Node.js (Server)"]
+        stdout["process.stdout.write"] --> capture["processStreamData()"]
+        stderr["process.stderr.write"] --> capture
+        capture --> |stripAnsi| serverBuffer["logBuffer (rolling 1000 lines)"]
+        capture --> |emit server-log| serverSse["GET /api/debug/server-logs (SSE)"]
+
+        ingestionRoute --> clientBuffer["clientLogBuffer (rolling 1000 lines)"]
+        ingestionRoute --> |emit client-log| clientSse["GET /api/debug/client-logs (SSE)"]
+    end
+```
+
+#### In-Process Interceptor (Stdout & Stderr)
+To guarantee 100% logging completeness without requiring complex and insecure external Docker daemon sockets, the server hooks directly into standard output stream writers `process.stdout.write` and `process.stderr.write` during the process boot cycle. 
+- Custom accumulators process streams, strip ANSI terminal colors (colors are stripped using a standard regex matching all terminal escape codes), and split incoming chunks into structured lines.
+- Historical lines are appended to a rolling in-memory array `logBuffer` capped at 1,000 entries.
+- Real-time logging events are broadcasted via a central `EventEmitter` allowing connected SSE stream clients to receive updates instantly.
+
+#### Client Console Log Capture
+To assist developers in troubleshooting client-side runtime errors without access to developer consoles (e.g., in embedded WebViews, smart TVs, or custom mobile browser instances), the SPA implements an automatic logging interceptor.
+- If `/api/debug/status` indicates log streaming is active, the bootstrap process replaces global `console.log`, `console.warn`, and `console.error` methods.
+- Logs are added to an in-memory queue and flushed in batches using a stateless `POST /api/debug/client-logs` request every 2,000ms (or when the queue size reaches 20 items) to prevent browser thread blocking.
+- A synchronous cleanup check is registered via standard `beforeunload` to flush any remaining logs using `navigator.sendBeacon()` or `keepalive: true` fetch on page refresh or navigate.
 
 ---
 
@@ -714,10 +1047,14 @@ sofarr/
 │   │   ├── TransmissionClient.js
 │   │   ├── RTorrentClient.js
 │   │   ├── PollingSonarrRetriever.js  PALDRA — Sonarr retriever
-│   │   └── PollingRadarrRetriever.js  PALDRA — Radarr retriever
+│   │   ├── PollingRadarrRetriever.js  PALDRA — Radarr retriever
+│   │   ├── ArrRetriever.js      PALDRA — Abstract base class for *arr retrievers
+│   │   ├── OmbiClient.js       Low-level Ombi API client
+│   │   └── OmbiRetriever.js    PALDRA — Ombi retriever with caching
 │   ├── routes/
 │   │   ├── auth.js             POST /login, GET /me, GET /csrf, POST /logout
-│   │   ├── dashboard.js        SSE /stream, /user-downloads, /user-summary, /status, /cover-art, /blocklist-search
+│   │   ├── dashboard.js        SSE /stream, /user-downloads, /blocklist-search
+│   │   ├── status.js           GET /api/status — admin server/polling/webhook status
 │   │   ├── history.js          GET /api/history/recent
 │   │   ├── webhook.js          POST /api/webhook/sonarr|radarr
 │   │   ├── sonarr.js           Sonarr API proxy + webhook management
@@ -727,6 +1064,12 @@ sofarr/
 │   ├── middleware/
 │   │   ├── requireAuth.js      httpOnly cookie auth enforcement
 │   │   └── verifyCsrf.js       Double-submit CSRF check (timing-safe)
+│   ├── services/               Download matching & assembly services
+│   │   ├── DownloadBuilder.js      Orchestrator: cache snapshot → matched downloads
+│   │   ├── DownloadMatcher.js      Match SABnzbd/qBittorrent to *arr records
+│   │   ├── DownloadAssembler.js    Pure helpers: cover art, links, episodes, blocklist
+│   │   ├── TagMatcher.js         Tag extraction, sanitisation, user matching
+│   │   └── WebhookStatus.js      Webhook configuration check + metrics aggregation
 │   └── utils/
 │       ├── arrRetrievers.js    PALDRA registry — Sonarr/Radarr fetch registry
 │       ├── cache.js            MemoryCache + webhook metrics helpers
@@ -738,15 +1081,37 @@ sofarr/
 │       ├── qbittorrent.js      Legacy compatibility shim → QBittorrentClient
 │       ├── sanitizeError.js    Secret redaction from errors/logs
 │       └── tokenStore.js       Emby token store (JSON file, atomic writes, 31-day TTL)
-├── public/                     Static SPA (served by Express)
+├── client/                     Frontend source (vanilla ES modules)
+│   ├── src/
+│   │   ├── main.js             Bootstrap entry point
+│   │   ├── state.js            Global reactive state
+│   │   ├── api.js              HTTP fetch wrappers
+│   │   ├── sse.js              EventSource management
+│   │   ├── ui/
+│   │   │   ├── auth.js
+│   │   │   ├── downloads.js
+│   │   │   ├── filters.js
+│   │   │   ├── history.js
+│   │   │   ├── statusPanel.js
+│   │   │   ├── tabs.js
+│   │   │   ├── theme.js
+│   │   │   └── webhooks.js
+│   │   └── utils/
+│   │       ├── format.js
+│   │       └── storage.js
+│   ├── index.html              Development HTML shell
+│   ├── package.json            Frontend dev dependencies (vite)
+│   └── vite.config.js          Build config → ../public/app.js
+├── public/                     Static SPA assets (served by Express)
 │   ├── index.html              HTML shell: splash, login, dashboard
-│   ├── app.js                  All frontend logic
+│   ├── app.js                  Bundled frontend (Vite build output)
 │   ├── style.css               Themes, layout, responsive design
 │   ├── favicon.ico / *.png     Favicons
 │   └── images/                 Logo / splash screen assets
 ├── tests/
 │   ├── README.md               Testing approach and coverage targets
 │   ├── setup.js                Global setup: isolated DATA_DIR, rate-limit bypass
+│   ├── frontend/               Vitest + jsdom unit tests for client/src
 │   ├── unit/                   Pure unit tests (no HTTP)
 │   └── integration/            Supertest + nock integration tests
 ├── .gitea/workflows/
@@ -755,7 +1120,7 @@ sofarr/
 │   ├── create-release.yml      Release tagging workflow
 │   ├── docs-check.yml          Markdown lint + Mermaid validation
 │   └── licence-check.yml       Production dependency licence check
-├── Dockerfile                  Multi-stage production image (node:22-alpine)
+├── Dockerfile                  Multi-stage production image (node:22-alpine) — includes Vite client build stage
 ├── docker-compose.yaml         Example compose deployment
 ├── vitest.config.js            Test runner configuration with per-file coverage thresholds
 ├── package.json                Dependencies and scripts
@@ -860,7 +1225,7 @@ Each instance receives an `id` derived from `name` (or index if unnamed), used a
 | Concern | Mechanism |
 |---------|-----------|
 | **Secret validation** | Every webhook request must carry `X-Sofarr-Webhook-Secret` matching `SOFARR_WEBHOOK_SECRET`. Absent or wrong secret → `401`. Webhook endpoints function outside the CSRF middleware (they are not browser-initiated). |
-| **Rate limiting** | Dedicated `webhookLimiter`: 60 req/min per IP (stricter than the general 300 req/15 min limiter). |
+| **Rate limiting** | Dedicated `webhookLimiter`: 60 req/min per IP (stricter than the general 300 req/15 min limiter). Bypassed in testing/dev via `SKIP_RATE_LIMIT=1`. |
 | **Payload validation** | `validatePayload()` enforces: JSON object body, `eventType` as a non-empty string ≤ 64 chars, `eventType` in the allowlist, `instanceName` as string if present. Rejects with `400` on any violation. |
 | **Replay protection** | `isReplay()` caches a composite key `{eventType}:{instanceName}:{date}` for 5 minutes. Duplicate events within that window are acknowledged with `200 { received: true, duplicate: true }` and not processed. |
 
@@ -868,13 +1233,25 @@ Each instance receives an `id` derived from `name` (or index if unnamed), used a
 
 | Concern | Mechanism |
 |---------|-----------|
-| **Rate limiting** | 300 req/15 min general (all API routes); 10 failed attempts/15 min login limiter; 60 req/1 min webhook limiter. |
+| **Rate limiting** | General API limiter (300 req/15 min on `/api/*` prefix) exempts `/api/dashboard/cover-art` requests; Login limiter (10 attempts/15 min) employs `skipSuccessfulRequests: true` to count failed attempts only; Webhook limiter runs 60 req/1 min on `/api/webhook/*` endpoints; Root `/health` and `/ready` probes are entirely exempt. All limiters bypassable in testing via `SKIP_RATE_LIMIT=1` or `createApp({ skipRateLimits: true })`. |
 | **Secret leakage** | `sanitizeError()` (`server/utils/sanitizeError.js`) redacts secrets from error messages and logs: URL query-param secrets (`apikey=`, `token=`), HTTP auth headers (`Authorization:`, `X-Emby-Authorization:`), Bearer tokens, and basic-auth credentials in URLs. |
 | **HTTP headers** | Helmet v7: CSP with per-request nonce (`crypto.randomBytes(16)` for inline styles/scripts), HSTS, `X-Frame-Options: DENY`, `X-Content-Type-Options: nosniff`, `Referrer-Policy`, `Permissions-Policy`. |
 | **Body size** | `express.json` body limit: 64 KB. |
 | **Authorisation matrix** | Regular users see only their own downloads. Admins can view all users, see paths and *arr links, and blocklist any download. Non-admins can only blocklist when import issues exist or (for qBittorrent) the torrent is >1 h old with <100% availability. |
 | **Container security** | Docker image runs as the non-root `node` user (UID 1000). `/app/data` is owned by `node`. |
 
+### 10.4 Debug Log Streaming Security
+
+Access to the debug log stream endpoints (`/api/debug/server-logs` and `/api/debug/client-logs`) is secured via a strict multi-layered policy:
+
+| Layer | Mechanism |
+|-------|-----------|
+| **Feature lock toggle** | Strictly disabled by default; only enableable when environment variable `ENABLE_LOG_STREAM=true` is set. |
+| **Subnet filtering** | If environment variable `LOG_ALLOW_SUBNETS` is configured (using standard comma-separated CIDR notation), incoming client IPs (`req.ip`) are parsed and validated via the `ipaddr.js` library. Unmatched subnets receive a `403 Forbidden` response immediately. |
+| **Fast-path webhook bypass** | A valid webhook secret bypasses the active Emby authentication layer when provided on the `X-Webhook-Secret` header. |
+| **Active Emby session** | Validates that an active `emby_user` session cookie is present and that the authenticated Emby user is an administrator. |
+| **Emby basic auth fallback** | Allows Basic Authentication headers by performing an on-demand asynchronous credentials check against Emby's `/Users/authenticatebyname` and `/Users/{id}` endpoints to assert active policy administrator status. |
+
 ---
 
 ## 11. Technology Stack
@@ -887,9 +1264,10 @@ Each instance receives an `id` derived from `name` (or index if unnamed), used a
 | Framework | Express 4.x | HTTP server, routing, middleware |
 | HTTP client | axios 1.x | External API communication |
 | XML-RPC client | xmlrpc 1.3.2 | rTorrent communication |
-| Frontend | Vanilla JS + CSS | SPA, no build step required |
+| Frontend | Vanilla JS + CSS | SPA; Vite bundles ES modules from `client/src/` into `public/app.js` |
 | Containerisation | Docker multi-stage (node:22-alpine) | Non-root `node` user; minimal image |
 | Logging | Custom logger + `console.*` redirection | File + stdout with configurable levels |
+| Request Management | Ombi (optional) | External ID matching and request linking |
 
 ### Security Middleware
 
@@ -899,6 +1277,15 @@ Each instance receives an `id` derived from `name` (or index if unnamed), used a
 | `express-rate-limit` | 7.x | General, login, and webhook rate limiters |
 | `cookie-parser` | 1.x | Signed cookie support (HMAC via `COOKIE_SECRET`) |
 
+### API Documentation
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| `swagger-ui-express` | 5.x | Serve interactive Swagger UI at `/api/swagger` |
+| `swagger-jsdoc` | 6.x | Merge JSDoc `@openapi` comments with central YAML spec |
+| `yamljs` | 0.3.x | Parse `server/openapi.yaml` at runtime for swagger-jsdoc |
+| `@stoplight/spectral-cli` | 6.x (dev) | Lint OpenAPI spec for correctness in CI |
+
 ### Auth and Session
 
 | Component | Technology | Details |
@@ -915,12 +1302,13 @@ Each instance receives an `id` derived from `name` (or index if unnamed), used a
 | `vitest` | 4.x | Test runner with V8 coverage; per-file coverage thresholds in `vitest.config.js` |
 | `supertest` | 7.x | HTTP integration testing against the Express app factory |
 | `nock` | 14.x | HTTP interception at Node layer (compatible with CJS `require('axios')`) |
+| `jsdom` | 24.x | Browser-like DOM environment for frontend unit tests |
 
 ### CI/CD
 
 | Workflow file | Trigger | Purpose |
 |---------------|---------|---------|
-| `ci.yml` | Every push / PR | `npm audit --audit-level=high` + full test suite with V8 coverage |
+| `ci.yml` | Every push / PR | `npm audit --audit-level=high` + full test suite (unit, integration, frontend) with V8 coverage |
 | `build-image.yml` | Push to `release/**` or `develop` | Build and push Docker image to registry |
 | `create-release.yml` | Tag push (`v*`) | Generate release notes and create a Gitea release |
 | `docs-check.yml` | Push / PR touching `**.md` | Markdown lint + Mermaid diagram parse validation |

CHANGELOG.md

@@ -3,6 +3,511 @@
 All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [1.7.35] - 2026-05-29
+
+### Added
+
+- **Orphaned *arr Queue Item Support (Issue #73)** — Added support for active Sonarr/Radarr queue items from unconfigured download clients ("orphaned" downloads). Added a new synthetic client (`'orphaned'`) with a custom viewBox vector graphics asset at `/images/clients/orphaned.svg` to represent unconfigured clients, and updated filter dropdown lists and active downloads grids to cleanly display them with a dimmed logo, custom dashed border styling, and informative hover tooltips. Resolves Gitea Issue [#73](https://git.i3omb.com/Gandalf/sofarr/issues/73).
+
+### Enhanced
+
+- **Download Matching & JSDoc Hygiene (Issue #73)** — Refactored core active-download matching algorithms into unified, deduplicated helper functions (`normalizeTitle`, `titleMatches`, `buildArrDownload`) in `DownloadMatcher.js`, preventing hundreds of lines of duplicate code. Handled case-insensitive and type-safe `downloadId` lookup in `matchSabHistory` across both history and active queue records. Added safe progress arithmetic bounds checking to prevent division-by-zero or `NaN`.
+
+### Fixed
+
+- **Security Metadata Isolation in buildArrDownload (Issue #73)** — Restricted access control for sensitive properties like `arrInstanceKey` (the raw instance API key) to ensure they are strictly stripped out of download objects for non-administrator users, preserving system security boundaries.
+
+## [1.7.34] - 2026-05-28
+
+### Fixed
+
+- **Webhook Test Duplicate Error (Issue #71)** — Skipped duplicate/replay protection for `"Test"` event types in Sonarr and Radarr webhook handlers, resolving test button failures. Resolves Gitea Issue [#71](https://git.i3omb.com/Gandalf/sofarr/issues/71).
+
+### Enhanced
+
+- **Unified Tab Header Layout & Typography Consistency (Issue #72)** — Added consistent titles, subtitles, and icons across Active Downloads, Recently Completed, and Requests tab panels, and refactored styling to use a unified flexbox design with CSS variables. Resolves Gitea Issue [#72](https://git.i3omb.com/Gandalf/sofarr/issues/72).
+
+## [1.7.33] - 2026-05-28
+
+### Added
+
+- **Requests Tab Layout Enhancement (Issue #69)** — Redesigned and unified the Requests tab container and card layouts with the Active Downloads and Recently Completed tabs. Added styled media-type borders (`tv` and `movie`) using system color variables, styled the `.requests-container` with a surface card background (`var(--surface)`) and box shadow, converted `.requests-list` to a column flexbox (`display: flex; flex-direction: column; gap: 8px;`), aligned card items to the top (`align-items: flex-start`), tighter padding (`10px 14px`), and border-radius (`6px`), and scaled `.request-type-icon` to `48px` wide and `68px` high as a clean cover-art placeholder. All changes are strictly scoped to the requests tab element selectors, leaving active and recent downloads 100% untouched. Resolves Gitea Issue [#69](https://git.i3omb.com/Gandalf/sofarr/issues/69).
+
+### Fixed
+
+- **Webhook Regression (Issue #70)** — Fixed a critical regression introduced in #62 where the Ombi webhook handler called `isReplay()` with 3 arguments instead of the new 4-argument signature (`eventType, instanceName, eventDate, contentId`). The handler now correctly passes `requestId` as the fourth `contentId` argument. This restores reliability to real Ombi webhooks, loopback fallbacks, and the Ombi test simulation buttons. Resolves Gitea Issue [#70](https://git.i3omb.com/Gandalf/sofarr/issues/70).
+
+## [1.7.32] - 2026-05-28
+
+### Fixed
+
+- **TransmissionClient Hardening (Issue #63)** — Mapped the previously-unknown Transmission RPC status code `7` to `Checking` (best-effort; the RPC spec formally documents only codes 0–6, and the historical alias `TORRENT_IS_CHECKING` corresponds to code 2), so torrents reporting code 7 are now rendered with a useful status label instead of `Unknown`. Implemented three torrent control methods on `TransmissionClient` that were previously absent: `startTorrent(id)` (resumes via `torrent-start`), `stopTorrent(id)` (pauses via `torrent-stop`), and `removeTorrent(id, deleteData = false)` (removes via `torrent-remove`, optionally also deleting local files via Transmission's `delete-local-data` flag). All three accept either a single id (numeric or hash) or an array of ids, matching the Transmission RPC contract. Documented in `extractArrInfo()` that an `arrQueueId` cannot reliably be derived from filename alone — the cross-client matching path is hash-based via `DownloadMatcher.matchTorrents()` (Issue #65), which keys on `torrent.hashString` for Transmission. Added regression tests for status code 7 and all three control methods. Resolves Gitea Issue [#63](https://git.i3omb.com/Gandalf/sofarr/issues/63).
+- **Frontend Build Stability (Issue #66)** — Added explanatory inline comments to `client/vite.config.js` documenting two non-standard but deliberate build settings: `build.outDir = '../public'` (the Vite bundle is emitted into the Express-served `public/` directory at the repo root rather than the Vite-default `client/dist/`) and `build.emptyOutDir = false` (required so the hand-authored static assets committed under `public/` are not wiped by every `vite build`). The comments explicitly warn that changing either setting without also updating the Express static-serve configuration in `server/app.js` and the Dockerfile copy steps will break production serving. Removed a stale, untracked `client/dist/` directory (a leftover from an earlier default-Vite build) that was harmless — both `.gitignore` and `.dockerignore` already excluded it from version control and Docker contexts — but caused recurring confusion about which `index.html` was authoritative. Verified `client/index.html` correctly references `/src/main.js` as the Vite entrypoint. Resolves Gitea Issue [#66](https://git.i3omb.com/Gandalf/sofarr/issues/66).
+- **Download Matching & Deduplication (Issue #65)** — `DownloadMatcher.matchTorrents()` now attempts hash-first matching for every torrent before falling back to title-substring matching. The hash lookup compares `torrent.hash` (qBittorrent, rTorrent) or `torrent.hashString` (Transmission) against each *arr* queue/history record's `downloadId`, restoring deterministic matching for renamed downloads and torrents whose on-disk filename has diverged from the *arr* release title. Title-substring matching is retained verbatim as a fallback so unhashed clients and legacy fixtures continue to work. After the per-torrent matching pass, the returned list is deduplicated by the composite key `(arrType, arrQueueId)`: the first matched download wins, so a single torrent that maps to N *arr* queue records sharing one queue id (for example, a season pack exposed as multiple per-episode rows) produces a single dashboard card instead of N near-identical duplicates. A new integration suite at `tests/integration/download-matcher-season-pack.test.js` covers hash-first matching for qBittorrent (`hash`) and Transmission (`hashString`), the title-substring fallback path, and the deduplication step. Resolves Gitea Issue [#65](https://git.i3omb.com/Gandalf/sofarr/issues/65).
+- **qBittorrentClient Peer Data & Response Safety (Issue #64)** — `QBittorrentClient.normalizeDownload()` now exposes two new fields on every torrent record: `seeds` (sourced from qBittorrent's `num_seeds`, the count of connected seed peers) and `peers` (sourced from `num_leechs`, the count of connected leecher peers). The connected counts were chosen deliberately over the swarm totals `num_complete`/`num_incomplete` so the values remain consistent with what other clients (Transmission via `peersConnected`/`peersSendingToUs`, rTorrent via `d.peers_connected`) report on the same normalised contract. `QBittorrentClient.getMainData()` now also defensively returns the existing in-memory torrent map (rather than dereferencing a null) when the qBittorrent server responds with an empty body to `/api/v2/sync/maindata`, eliminating a crash class observed against transiently-restarting qBittorrent instances. A regression test verifies the new fields are populated from `num_seeds`/`num_leechs` and not from the swarm-total fields. Resolves Gitea Issue [#64](https://git.i3omb.com/Gandalf/sofarr/issues/64).
+- **Season Pack Queue Handling & Crash Prevention (Issue #61)** — Extracted a shared `buildArrQueueCache(queues, instances, mediaKey)` helper at `server/utils/arrQueueHelpers.js` covering both Sonarr and Radarr, replacing four previously-divergent inline `flatMap` blocks across the background poller (`server/utils/poller.js`) and the webhook event processor (`server/routes/webhook.js`) that built the `poll:sonarr-queue` and `poll:radarr-queue` cache entries. Sonarr queue records that share a `downloadId` (the canonical fingerprint for a season-pack release) are now annotated with `isSeasonPack: true` and `episodeCount: <n>` so downstream consumers — including the active-downloads matching service — can identify and de-duplicate season packs without re-deriving the grouping. The helper is wrapped in per-record and per-instance `try`/`catch` guards: malformed records (`null`, missing `data`, unknown instance ids) are skipped with a warning rather than throwing, eliminating a class of crashes that previously bubbled out of the `flatMap` and tore down the entire poll cycle or webhook refresh. Movies (Radarr) skip season-pack annotation by design. A new unit test suite at `tests/unit/utils/arrQueueHelpers.test.js` covers tagging, season-pack grouping, null-safety, and unknown-instance fallback. Resolves Gitea Issue [#61](https://git.i3omb.com/Gandalf/sofarr/issues/61).
+- **rTorrent Null-Safety, SABnzbd History Limit & Client Last-Error Visibility (Issue #68)** — Three related hardening improvements to the download-client layer. First, `RTorrentClient` now defends against the malformed-response scenarios observed against misconfigured or transiently-restarting rTorrent servers: `getActiveDownloads()` explicitly checks that `d.multicall2` returned an actual array (logging a warning and returning `[]` if not, rather than throwing on `.map`) and processes each torrent row in its own `try`/`catch` so a single malformed entry cannot poison the whole result set. All eleven field values retrieved from the multicall response are coerced to their expected types via explicit `Number()`/`String()` conversions in `normalizeDownload()`, so downstream arithmetic and string operations can no longer blow up on `null` or `undefined` values from plugins or older rTorrent versions. `_extractArrInfo()` now short-circuits safely on non-string filenames. `getClientStatus()` additionally coerces the global rate values through `Number.isFinite` before returning them. Second, the SABnzbd history limit (previously hard-coded to `10` records per poll) is now configurable via the `SAB_HISTORY_LIMIT` environment variable. Invalid or absent values fall back to the default of `10` with a log warning, ensuring backward compatibility. Third, all four download clients (`RTorrentClient`, `SABnzbdClient`, `QBittorrentClient`, `TransmissionClient`) now record structured `lastError` objects (`{ operation, message, at }`) on every failed API call via `_recordLastError()` and clear them on subsequent success via `_clearLastError()` — both helpers introduced on the `DownloadClient` base class alongside the public `getLastError()` accessor. The per-client last-error is surfaced through `DownloadClientRegistry.getAllClientStatuses()` and exposed on the `GET /api/status/status` admin endpoint under the new `downloadClients` array, letting the admin panel show a per-client failure indicator without log scraping. New regression tests cover all null-safety paths, the SAB history limit env variable (unset, valid, invalid, propagated to the API call), and the full lastError set/clear cycle for both rTorrent and SABnzbd. Resolves Gitea Issue [#68](https://git.i3omb.com/Gandalf/sofarr/issues/68).
+- **Webhook Reliability (Issue #62)** — Hardened the webhook replay protection to prevent false-duplicate detection while preserving protection against genuine retries. The replay key for Sonarr and Radarr now incorporates a content identifier (`downloadId`, falling back to `series.id` or `movie.id`) alongside the existing `eventType:instanceName:eventDate` components, so that multiple distinct events sharing the same timestamp (for example, several `Grab` events fired in the same second for episodes in a season pack) no longer collide and get silently dropped. Events without a content identifier (such as `Test`) fall back gracefully to the previous key shape so existing behaviour is preserved. The Ombi handler — which already uses a distinct `requestId`-bearing key — is unchanged. Additionally, the Sonarr and Radarr handlers now log an explicit warning when the inbound `instanceName` fails to match any configured instance and processing falls back to the first instance, improving diagnosability of misconfigured webhook senders. Resolves Gitea Issue [#62](https://git.i3omb.com/Gandalf/sofarr/issues/62).
+
+## [1.7.31] - 2026-05-28
+
+### Fixed
+
+- **Frontend Connection Remediation** — Staged and committed dynamic proxy target configurations and startup pipeline orchestrations. Rebuilt the production build of `public/app.js` to ensure dynamic SSL bypass and dynamic local network address resolution are fully compiled and deployed.
+
+## [1.7.30] - 2026-05-28
+
+### Added
+
+- **Testing Scope Expansion (Issue #60)** — Significantly expanded unit and integration test coverage targeting the background polling engine, rate limiting, and frontend rendering logic to secure core behaviors.
+  - **Background Poller Tests (`poller.test.js`)**: Implemented robust unit tests verifying concurrency guards, subscriber registries (`onPollComplete`/`offPollComplete`), graceful error recovery, webhook bypasses, and global fallbacks using a hybrid testing approach with Vitest fake timers.
+  - **Isolated Rate Limiting (`rateLimiter.test.js`)**: Designed a dedicated integration test that unsets `SKIP_RATE_LIMIT` and asserts `429 Too Many Requests` responses under rapid login requests while maintaining test suite stability.
+  - **Active Downloads Decoration (`ombiDecoration.test.js`)**: Covered deep-link generation (`arrLink`) for active download matching under admin and non-admin states.
+  - **Frontend UI Rendering (`downloads.test.js`)**: Expanded coverage for the downloads rendering engine, specifically targeting conditional administrative icon construction (`createServiceIcons()`) and client logo loading fallbacks (`createClientLogo()`).
+  - **SSE Connection Lifecycle & Payload Contracts (`dashboard.test.js`)**: Added stream tests checking Server-Sent Event heartbeat emission, payload schema schemas, and client close event listeners (`req.on('close')`) to verify callback cleanup and prevent connection-based memory leaks.
+
+## [1.7.29] - 2026-05-27
+
+### Fixed
+
+- **Missing Radarr/Sonarr Links on Active Downloads (Issue #59)** — Resolved a bug where Radarr and Sonarr deep-link buttons were missing from active/completed download cards on the main dashboard for administrator users. Implemented a generic link enrichment utility `decorateDownloadsWithArrLinks()` to query Radarr and Sonarr catalog APIs in parallel and match downloads via their database ID or title, circumventing minimal metadata in cached records that lacked `titleSlug`. Added a robust integration test to safeguard links decoration for dashboard downloads.
+
+## [1.7.28] - 2026-05-27
+
+### Fixed
+
+- **Missing Sonarr Link on TV Requests (Issue #58)** — Resolved a bug where the Sonarr deep-link button was missing on TV request cards while Radarr links correctly appeared on movie request cards. Added support for all camelCase TVDB ID variants (`tvDbId`, `tvdbId`, `theTvdbId`, `theTvDbId`, `TvDbId`, `TheTvDbId`) on both backend link decoration (`server/utils/ombiHelpers.js`) and frontend rendering (`client/src/ui/requests.js`). Added a dedicated integration test to safeguard links decoration for TV requests.
+
+## [1.7.27] - 2026-05-27
+
+### Fixed
+
+- **Frontend Dashboard Serve Regression (Issue #57)** — Resolved a critical regression where the Vite-built frontend dashboard UI was not served. Consolidated Express configurations by migrating static files serving and SPA routing into the `createApp` factory in `server/app.js`. Cleaned up `server/index.js` to import and instantiate the app from the factory, successfully eliminating over 300 lines of duplicate route and middleware registrations, and ensuring alignment between development testing and production runtime configurations.
+
+## [1.7.26] - 2026-05-27
+
+### Fixed
+
+- **Missing Ombi & \*Arr Request Links (Issue #56)** — Resolved an issue where the Ombi and \*Arr lookup buttons failed to appear against request cards. Added `decorateRequestsWithArrLinks` to aggregate IDs and query Radarr/Sonarr libraries during SSE stream decoration and backend REST fetching. Also fixed a frontend condition failing to generate Ombi links for TV requests by checking a broader set of ID properties (`theTvDbId`, `theTmdbId`, `imdbId`).
+
+## [1.7.25] - 2026-05-27
+
+### Fixed
+
+- **Ombi TV Request Status, User, and Date Resolution (Issue #53)** — Resolved the root cause where Ombi TV show requests consistently displayed "unknown" status, "unknown" user, and missing request dates. The Ombi API nests all TV request data (`requestedUser`, `approved`, `available`, `denied`, `requested`, `requestedDate`) inside `childRequests[]` sub-objects, while the application previously only inspected top-level properties.
+  - `OmbiRetriever._hydrateRequest()` now hydrates `requestedUser` on each `childRequests` entry and promotes `requestedDate` from `childRequests[0]` to the top level.
+  - `getRequestStatus()` (server and client) now aggregates status flags from `childRequests[]` when top-level properties are absent.
+  - Client-side date display now falls back to `childRequests[0].requestedDate` as a defensive measure.
+
+## [1.7.24] - 2026-05-27
+
+### Enhanced
+
+- **Gitea Actions Prioritization** — Optimized CI/CD workflow pipeline executions to prioritize critical `build-image` Docker compilation runs. Redundant security audits, tests, coverage generation, and RAML packages are now bypassed on `release/**` branches (which have already passed validation during development on `develop`).
+- **Workflow Concurrency Controls** — Configured active concurrency groups with `cancel-in-progress: true` inside both `ci.yml` and `build-image.yml` pipelines, ensuring obsolete running jobs are aborted instantly when newer commits are pushed.
+
+## [1.7.23] - 2026-05-27
+
+### Enhanced
+
+- **Request Card Link Alignment (Issue #55)** — Aligned deep links on request cards (Ombi link and administrator Sonarr/Radarr deep links) with the elegant, inline `.service-icon` styling used across the downloads and history dashboard cards. Replaced bulky button elements with clean hoverable icons in a shared `.service-icons-container`, maintaining strict administrator-only visibility for *arr links.
+
+## [1.7.22] - 2026-05-27
+
+### Fixed
+
+- **Theme Switcher Multi-Button Support (Issue #54)** — Resolved a frontend bug where themes other than Light failed to apply because the Javascript code queried a non-existent `#theme-toggle` element. Re-engineered the switcher to query all `.theme-btn` selectors inside `.theme-switcher`, managing and toggling the active class styling across `light`, `dark`, and `mono` themes, and cleanly persisting choices to local storage.
+- **Ombi TV Requester User Extraction Fallback (Issue #53)** — Resolved a bug where TV show requests from Ombi displayed as "unknown" user because requester attributes were nested under non-standard properties (`user`, `requestedBy`, `ombiUser`, `requestedByUser`, and nested seasons/child requests arrays). Added robust multi-layer extraction logic on both backend and frontend layers to resolve requester usernames under all TV request structures.
+- **Configurable Webhook Commit Delay & Retry Loop (Issue #53)** — Mitigated race conditions between Ombi webhook events and database commits by introducing a configurable `OMBI_WEBHOOK_REFRESH_DELAY_MS` delay (defaulting to `2000`) and a smart 3-attempt retry polling loop to verify updated requester data before cache updates.
+
+### Added
+
+- **Admin Request Card *arr Library Lookup (Issue #53)** — Added library deep-link lookup for admin views. Request cards now query Sonarr and Radarr library caches and dynamically render deep-link navigation icons in the card actions container if the item exists.
+- **Request Date/Time Presentation** — Added request date and time display inside request cards formatted as `YYYY-MM-DD HH:MM`.
+- **Unknown (Ombi) Dotted Underline Tooltip** — Added user-friendly placeholder "Unknown (Ombi)" with dotted underline and explanatory hover tooltip when user details are unavailable from the Ombi database.
+- **Expanded Test Coverage** — Introduced two new frontend DOM test suites (`tests/frontend/ui/theme.test.js` and `tests/frontend/ui/requests.test.js`) and robust backend unit test assertions in `tests/unit/ombiHelpers.test.js`.
+
+---
+
+## [1.7.21] - 2026-05-26
+
+### Fixed
+
+- **Ombi Webhook Test Loopback Fallback** — Resolved a persistent failure on the Ombi webhook test button when Sofarr sits behind a reverse proxy or in loopback-restricted environments. When the outbound request to the public webhook URL (`SOFARR_BASE_URL`) fails due to loopback/NAT routing limits, the server now transparently falls back to a secure local loopback request (`127.0.0.1`) with smart TLS detection and SSL error bypass (`rejectUnauthorized: false`).
+- **Resilient Webhook Mocks in Tests** — Updated integration test assertions to verify the loopback fallback path under both HTTP and HTTPS configurations, ensuring full compatibility across dev, test, and production container environments.
+
+---
+
+## [1.7.21] - 2026-05-26
+
+### Fixed
+
+- **Webhook Loopback & Hairpin NAT Connectivity** — Implemented a robust local loopback fallback inside the Ombi webhook testing endpoint to bypass NAT loopback and DNS resolution issues common in setups behind reverse proxies. When the outbound request to the public URL fails, the server automatically routes the request internally via `127.0.0.1` using automatic TLS credentials detection and SSL validation bypass for loopback requests. Added comprehensive integration tests verifying the fallback behavior.
+- **Dedicated Webhook Base URL Support** — Added support for a new `SOFARR_WEBHOOK_BASE_URL` environment variable inside `server/routes/sonarr.js`, `server/routes/radarr.js`, and `server/routes/ombi.js`. This allows setups behind reverse proxies to declare an internal/custom base URL specifically for webhooks, enabling Sonarr, Radarr, and Ombi to send webhook events directly to the server via internal container networking, resolving `503 Service Unavailable` errors.
+
+---
+
+## [1.7.20] - 2026-05-26
+
+### Fixed
+
+- **Ombi Requesting User Hydration (Issue #51)** — Resolved a bug where Sofarr displayed "Unknown" for the requesting user on requests even when the Ombi database contains valid user information. Added automatic requestedUser object hydration on the server side by fetching the full user list from `/api/v1/Identity/Users` and caching it in memory. If a request is missing the nested `requestedUser` details but possesses a valid `requestedUserId`, Sofarr automatically resolves and binds the user's username/alias. Added robust unit tests safeguarding the client and the retriever. Resolves Gitea Issue [#51](https://git.i3omb.com/Gandalf/sofarr/issues/51).
+
+### Changed
+
+- **Aligned Gitea Interaction Skill** — Updated `.windsurf/skills/gitea-interaction/SKILL.md` to align with the Antigravity `tea-interaction` hybrid interaction model guidelines, detailing when to use the editor extension versus the Gitea CLI.
+
+---
+
+## [1.7.19] - 2026-05-25
+
+### Fixed
+
+- **Requests Mobile CSS Overflow Fix (Issue #49)** — Resolved the remaining viewport overflow on narrow screens by adding `min-width: 0` to `.request-card` to allow proper flexbox and grid shrinking, reducing mobile `.main-tabs` padding to `0 8px`, and tightening `.requests-container` mobile padding to `8px`.
+- **Admin *arr Badge Links on Active Downloads (Issue #50)** — Fixed the missing Sonarr/Radarr badges and links on active downloads for admin users. Enabled robust `_instanceUrl` propagation during queue/history metadata compilation (`buildMetadataMaps`) and active matching (`DownloadMatcher.js`) to ensure link generation succeeds. Added complete schema documentation in OpenAPI.
+
+---
+
+## [1.7.18] - 2026-05-24
+
+### Fixed
+
+- **Mobile overflow on Requests tab** — Request cards no longer extend off the right edge of the screen on mobile browsers. Removed `white-space: nowrap` from `.request-title` to allow text truncation with ellipsis, added `overflow-x: hidden` to `.requests-list` as a safety net, and added `@media (max-width: 768px)` rules to reduce padding and tighten gaps on mobile. Resolves Gitea Issue [#49](https://git.i3omb.com/Gandalf/sofarr/issues/49).
+
+---
+
+## [1.7.17] - 2026-05-24
+
+### Fixed
+
+- **Blocklist-Search Persistent Failure (Regression from v1.7.16)** — Identified and corrected the true root cause of the blocklist-and-search feature being non-functional. The v1.7.16 fix correctly cast both sides of the queue ID comparison to `String`, but the lookup was performed against `downloadClientRegistry.getAllDownloads()`, which returns **raw download-client data** (qBittorrent, SABnzbd, etc.) that never has `arrQueueId` populated — that field is only assigned by `DownloadMatcher.js` during the SSE build phase from the *arr cache. For qBittorrent torrents specifically, `QBittorrentClient.normalizeDownload()` does not set `arrQueueId` at all, so the lookup always returned `undefined` and the request was rejected with `403`. The permission check in `POST /api/dashboard/blocklist-search` now looks up the queue record directly from the Sonarr/Radarr queue cache (`poll:sonarr-queue` / `poll:radarr-queue`) where `record.id` is the numeric queue ID, using `String()` casting on both sides to handle the DOM-dataset (string) vs API response (number) type difference. Resolves Gitea Issue [#48](https://git.i3omb.com/Gandalf/sofarr/issues/48) (regression).
+
+---
+
+## [1.7.16] - 2026-05-24
+
+### Fixed
+
+- **Blocklist-Search Queue ID Type Mismatch** — Resolved a bug where the "Blocklist and search" action consistently returned `403 Download not found or permission denied` for all users. The server-side download lookup in `server/routes/dashboard.js` used strict equality (`===`) to compare `arrQueueId` values, but the value sent from the SPA client (read from a DOM `data-*` attribute) is always a `string`, while the value populated from the Radarr/Sonarr queue API is a `number`. Both sides are now cast to `String` before comparison, resolving the false-negative match failure. Resolves Gitea Issue [#48](https://git.i3omb.com/Gandalf/sofarr/issues/48).
+
+---
+
+## [1.7.15] - 2026-05-24
+
+### Fixed
+
+- **Ombi Webhook Authentication Failures** — Resolved a critical issue where Ombi webhook notifications failed to authenticate because Ombi's built-in notification agent does not support custom HTTP headers (such as `X-Sofarr-Webhook-Secret`). Added a query parameter authentication fallback (`?secret=`) to all `/api/webhook/*` endpoints (Sonarr, Radarr, and Ombi) and configured Ombi webhook registration to automatically append this secret query parameter. Resolves Gitea Issue [#47](https://git.i3omb.com/Gandalf/sofarr/issues/47).
+
+---
+
+## [1.7.14] - 2026-05-24
+
+### Fixed
+
+- **Undefined Reference Error in Background Poller** — Resolved a critical runtime exception in the background scheduler loop (`server/utils/poller.js`) where `logToFile` was called on cache updates but was never imported at the top of the file, previously triggering `[Poller] Poll error: logToFile is not defined` on every interval loop.
+
+---
+
+## [1.7.13] - 2026-05-24
+
+### Changed
+
+- **Comprehensive OpenAPI & Swagger Specification Remediation** — Bumped the API documentation version to `1.7.13` and fully documented all operational rate-limiting configurations, exemptions, and bypasses in `server/openapi.yaml` (including general cover-art exclusions, failed-only login trackers, webhook limiters, and rate-limit exempt root health probes).
+- **Aligned Health Check Endpoint Implementation** — Enhanced the express application factory `/health` endpoint to dynamically require and return the active version from `package.json`, keeping it fully aligned with the production entrypoint server logic.
+- **Synchronized Security & System Architecture Docs** — Aligned security matrices and threat mitigations in `SECURITY.md` and rate-limiting testing configurations in `ARCHITECTURE.md`.
+
+### Added
+
+- **Swagger API Coverage Verification Integration** — Implemented comprehensive assertions within `tests/integration/swagger-coverage.test.js` to dynamically verify that all newly added logging and debug endpoints (`/api/debug/*`) are fully represented in the active specification, raising test suite coverage to 876 passing checks.
+
+---
+
+## [1.7.12] - 2026-05-24
+
+### Added
+
+- **Real-Time Server-Side Log Streaming (`GET /api/debug/server-logs`)** — Introduced an in-process output stream capturer that intercepts standard output (`stdout`) and standard error (`stderr`), strips terminal ANSI escape codes, maintains a rolling 1000-line buffer, and streams live operational logs via Server-Sent Events (SSE). Resolves Gitea Issue [#45](https://git.i3omb.com/Gandalf/sofarr/issues/45).
+- **Real-Time Client-Side Console Log Stream (`GET & POST /api/debug/client-logs`)** — Added a browser-side console override in the frontend SPA that intercepts `console.log`, `console.warn`, and `console.error` calls. Logs are queued and posted to `/api/debug/client-logs` in optimized batches every 2000ms (or when the queue reaches 20 items), which are then buffered and streamed over SSE to debugging developers. Resolves Gitea Issue [#46](https://git.i3omb.com/Gandalf/sofarr/issues/46).
+- **Subnet IP Filtering (`LOG_ALLOW_SUBNETS`)** — Implemented an optional CIDR-based subnet validation check using `ipaddr.js` to restrict access to debug logs endpoints to specific internal IP ranges (e.g. `127.0.0.1/32,192.168.1.0/24`). Works natively with reverse proxies when `TRUST_PROXY` is enabled.
+- **Multi-Layered Security Bypass & Auth** — Debug endpoints are guarded globally by `ENABLE_LOG_STREAM=true` (off by default) and require Emby admin sessions, standard HTTP Basic Auth fallback checks against Emby, or high-priority bypass via header `X-Webhook-Secret`.
+- **Swagger UI Specification Coverage** — Fully documented all four new endpoints, headers, and schemas in `server/openapi.yaml`, with automated verification integrated inside `swagger-coverage.test.js`.
+- **Architectural & Developer Guides** — Updated `ARCHITECTURE.md` (with system overview, diagrams, stdout/stderr hooks, and threat mitigations) and `README.md` (deploy instructions and querying parameters).
+
+---
+
+## [1.7.11] - 2026-05-24
+
+### Fixed
+
+- **Sonarr full-season and multi-episode blocklist-search failures** — Fixed a bug where clicking the "Blocklist & Search" button on television downloads representing full-season packs or multi-episode releases failed with a `400 Bad Request` error. We relaxed the API validation on `POST /api/dashboard/blocklist-search` to make `arrContentId` optional. In `DownloadMatcher.js`, we exposed `arrContentIds` (holding all episode IDs associated with the matched release) and `arrSeriesId` (holding the series ID).
+- **Enhanced blocklist re-search commands** — The backend now triggers multi-episode `EpisodeSearch` commands using the `episodeIds` array when blocklisting multi-episode releases, and falls back to a series-wide `SeriesSearch` command using the `seriesId` when no specific episode IDs can be resolved.
+- **OpenAPI Schema and Test Coverage** — Updated the OpenAPI specifications (`server/openapi.yaml`) to reflect optional/new parameters on `BlocklistSearchRequest`, and implemented new integration tests in `tests/integration/dashboard.test.js` to safeguard fallback and multi-episode search commands.
+
+---
+
+## [1.7.10] - 2026-05-24
+
+### Fixed
+
+- **Ombi webhook race condition fix** — Introduced a 2000ms delay in the webhook background worker for Ombi events before fetching new requests. This resolves a race condition where Ombi triggers the webhook before its database has committed the new request, which previously caused the request to be missing from the subsequent API fetch. Resolves Gitea Issue [#42](https://git.i3omb.com/Gandalf/sofarr/issues/42).
+- **Ombi webhook statistics in status panel** — Integrated Ombi webhook metrics into the admin status panel. The backend now retrieves the Ombi webhook configuration status and aggregates its events received and polls skipped metrics. The frontend displays these metrics (consistently formatted as `O:<count>`) under the Webhooks status card.
+
+---
+
+## [1.7.9] - 2026-05-23
+
+### Fixed
+
+- **Ombi webhook PascalCase payload parsing (Re-release)** — Correctly packaged and released the Ombi webhook parsing logic to handle PascalCase property names (e.g., `NotificationType`, `RequestId`) sent by C#/.NET applications. This ensures standard Ombi webhook integrations function correctly. Resolves Gitea Issue [#42](https://git.i3omb.com/Gandalf/sofarr/issues/42).
+
+---
+
+## [1.7.8] - 2026-05-23
+
+### Fixed
+
+- **Ombi webhook PascalCase payload parsing** — Updated the Ombi webhook parsing logic to correctly handle payloads formatted with PascalCase property names (e.g. `NotificationType`, `RequestId`), which are often sent by C#/.NET applications. This ensures that new requests generated via Ombi's standard webhook integrations are correctly processed and displayed in the frontend dashboard. Resolves Gitea Issue [#42](https://git.i3omb.com/Gandalf/sofarr/issues/42).
+
+---
+
+## [1.7.7] - 2026-05-23
+
+### Fixed
+
+- **Ombi webhook NewRequest parsing support** — Added `'NewRequest'` to `VALID_EVENT_TYPES` and `OMBI_EVENTS` sets in `server/routes/webhook.js`. When a user submits a new media request in Ombi, the backend now successfully parses the webhook payload, bypasses the request cache, fetches the latest request list, and broadcasts it to all connected dashboard screens via SSE in real time. Previously, these webhook payloads were rejected with a `400 Bad Request` error. Resolves Gitea Issue [#42](https://git.i3omb.com/Gandalf/sofarr/issues/42).
+- **Ombi webhook integration tests** — Implemented a robust integration test suite in `tests/integration/webhook.test.js` validating `POST /api/webhook/ombi` payloads, secret keys, duplicate/replay protection, input checks, and cache refresh triggers.
+
+---
+
+## [1.7.6] - 2026-05-23
+
+### Fixed
+
+- **Bypass rate limiter for cover art** — Exempted `GET /api/dashboard/cover-art` requests from the global API rate limiter. Resolves Gitea Issue [#43](https://git.i3omb.com/Gandalf/sofarr/issues/43).
+- **Ombi request cache bypass** — Added a `force` cache-bypassing flag to `OmbiRetriever`'s cache refresh mechanism, enabling real-time cache updates upon receiving Ombi webhooks or manual request list reloads. Resolves Gitea Issue [#42](https://git.i3omb.com/Gandalf/sofarr/issues/42).
+
+---
+
+## [1.7.5] - 2026-05-23
+
+### Fixed
+
+- **Ombi webhook settings persistence** — Fixed a bug where enabling the Ombi webhook from the frontend was successfully processed by the server but not stored on the Ombi side. The payload submitted to Ombi now retrieves the database `id` of the settings row first and merges it back into the `POST` payload. This ensures Entity Framework Core on the Ombi backend performs an update on the correct database row, enabling the webhook and letting its status persist successfully. Resolves Gitea Issue [#41](https://git.i3omb.com/Gandalf/sofarr/issues/41).
+
+---
+
+## [1.7.4] - 2026-05-23
+
+### Fixed
+
+- **Ombi webhook registration in production** — Fixed a bug where `/api/ombi/webhook/enable` and other `/api/ombi/*` endpoints returned `404 (Not Found)` in production. The core Express app factory (`server/app.js`) registered the router, but the production server entry point (`server/index.js`) duplicated Express setup instead of utilizing the factory, omitting the `ombiRoutes` registration entirely. Re-registered the router in `server/index.js`, resolves Gitea Issue [#40](https://git.i3omb.com/Gandalf/sofarr/issues/40).
+
+---
+
+## [1.7.3] - 2026-05-23
+
+### Fixed
+
+- **Download client dropdown filter icons and type badges** — Refactored the download client selector dropdown in `client/src/ui/filters.js` to render utilizing the design system classes `.download-client-option`, `.download-client-icon`, `.download-client-option-label`, and `.download-client-type`. Options now display the client's brand SVG logo (e.g., `sabnzbd.svg`, `qbittorrent.svg` loaded from `/images/clients/`) next to the configured display name, along with a clean pill badge indicating the client type. This resolves visual ambiguity when multiple download clients share the same name (such as `"i3omb"` for SABnzbd and qBittorrent).
+
+---
+
+## [1.7.2] - 2026-05-22
+
+### Fixed
+
+- **Webhook configuration check** — Ombi webhook status now correctly checks for `SOFARR_BASE_URL` and `SOFARR_WEBHOOK_SECRET` environment variables. The webhook displays as disabled when either is missing, matching the existing *ARR webhook behavior.
+- **Common webhook config endpoint** — Added `GET /api/webhook/config` endpoint that returns whether both `SOFARR_BASE_URL` and `SOFARR_WEBHOOK_SECRET` are configured, along with a list of missing items. Used by the client to determine webhook enablement status across all webhook types.
+- **Client-side webhook status** — Updated `fetchWebhookStatus()` to call `/api/webhook/config` and use the result to determine if Sonarr and Radarr webhooks are enabled. Webhook status now depends on both the service-specific webhook being configured AND the Sofarr webhook config being valid.
+- **Webhook config endpoint authentication** — Added `requireAuth` middleware to `GET /api/webhook/config` to enforce authentication, matching the OpenAPI contract and preventing unauthenticated information disclosure.
+- **Ombi webhook enable/test config validation** — `POST /api/ombi/webhook/enable` and `POST /api/ombi/webhook/test` now validate `SOFARR_BASE_URL` and `SOFARR_WEBHOOK_SECRET` before making outbound Ombi API calls, returning `400` with descriptive errors when either is missing. Previously these routes would construct malformed URLs (`undefined/api/webhook/ombi`) if the environment variables were unset.
+- **Test environment cleanup** — `tests/integration/webhook.test.js` `afterEach` now cleans up `EMBY_URL`, `SOFARR_BASE_URL`, `SONARR_INSTANCES`, and `RADARR_INSTANCES` to ensure hermetic test isolation.
+
+---
+
+## [1.8.0] - 2026-05-21
+
+### Added
+
+#### Ombi PALDRA Integration
+
+- **OmbiRetriever** — New PALDRA-compliant retriever extending `ArrRetriever`, registered in `arrRetrieverRegistry` alongside Sonarr/Radarr. Manages Ombi request data with 5-minute TTL cache and lookup maps by TMDB/TVDB/IMDB IDs.
+- **OmbiClient** — Low-level Ombi API client for HTTP communication (movie/TV requests, search by external ID, connection test).
+- **`getOmbiInstances()`** — New config function in `server/utils/config.js` following the existing multi-instance JSON array pattern; supports both `OMBI_INSTANCES` and legacy `OMBI_URL`/`OMBI_API_KEY` formats.
+- **PALDRA registry Ombi methods** — `getOmbiRetrievers()`, `getOmbiRequests()`, `getOmbiRequestsByType()`, `findOmbiRequest()` added to `arrRetrieverRegistry`.
+- **External ID matching** — Downloads are matched to Ombi requests using TVDB ID → TMDB ID (TV) and TMDB ID → IMDB ID (movies); falls back to an Ombi search link when no request exists.
+- **`getOmbiLink()` / `getOmbiSearchLink()`** — New helpers in `DownloadAssembler.js` following the `getSonarrLink`/`getRadarrLink` pattern.
+- **Service icon layout** — Downloads and history cards now render inline SVG icons (Ombi for all users; Sonarr/Radarr for admins) instead of linked series/movie names. CSS `.service-icons-container` and `.service-icon` classes added to `public/style.css`.
+- **OpenAPI** — `NormalizedDownload` schema extended with `ombiLink`, `ombiRequestId`, `ombiTooltip` nullable string properties; `Ombi` tag added to the spec.
+- **`OMBI_INSTANCES` / `OMBI_URL` / `OMBI_API_KEY`** — New environment variables documented in `.env.sample`, `README.md`, `ARCHITECTURE.md`, and `SECURITY.md`.
+
+### Changed
+
+- **`DownloadMatcher.js`** — `matchSabSlots`, `matchSabHistory`, and `matchTorrents` are now `async`; each matched download object is enriched with `ombiLink`, `ombiRequestId`, and `ombiTooltip` via `addOmbiMatching()`.
+- **`DownloadBuilder.js`** — `buildUserDownloads` accepts `ombiRetriever` and `ombiBaseUrl` in its options object and passes them through to matching context.
+- **Dashboard routes** — Both the REST endpoint and SSE stream now resolve the Ombi retriever from the PALDRA registry and include it in the download-building context.
+- **`arrRetrievers.js`** — PALDRA registry now imports `OmbiRetriever`, maps `'ombi'` in `retrieverClasses`, and initialises instances from `getOmbiInstances()`.
+- **`ARCHITECTURE.md`** — PALDRA section updated with OmbiRetriever description, registry API additions, and directory-structure entries. Technology stack table updated.
+- **`SECURITY.md`** — Threat model extended with Ombi API key exposure and rate-limit exhaustion mitigations.
+- **`README.md`** — Prerequisites and new *Ombi Integration (Optional)* configuration section added.
+
+---
+
+## [1.7.1] - 2026-05-21
+
+### Added
+
+#### RAML 1.0 Package Generation
+
+- **Automated RAML generation in CI/CD** — Added RAML 1.0 package generation to the existing `swagger` job in `.gitea/workflows/ci.yml`. The pipeline now generates a downloadable `raml-package` artifact on every push and PR, available from the Actions run page with 14-day retention.
+- **RAML generation scripts** — Created three new scripts in `scripts/`:
+  - `generate-openapi.js` — Bootstraps the Express app in test mode, fetches the merged OpenAPI 3.1 spec from `/api/swagger.json`, and exports it to disk.
+  - `downgrade-openapi.js` — Downgrades OpenAPI 3.1 to 3.0 for RAML compatibility (existing RAML converters don't support 3.1).
+  - `simple-raml-converter.js` — Converts OpenAPI 3.0 to RAML 1.0 format using a custom converter (modern RAML converters are unmaintained).
+  - `package-raml.js` — Creates a versioned tar.gz archive containing the RAML spec, original OpenAPI spec, version metadata, and README.
+- **RAML artifact structure** — Each artifact includes:
+  - `api.raml` — RAML 1.0 specification
+  - `openapi-merged.json` — Original merged OpenAPI 3.1.0 spec (for reference)
+  - `version.json` — Metadata (version, commit SHA, timestamp, tool used)
+  - `README.md` — Origin, conversion details, known limitations, and verification steps
+- **npm scripts** — Added three new scripts to `package.json`:
+  - `generate:openapi` — Generates merged OpenAPI spec
+  - `generate:raml` — Downgrades and converts to RAML
+  - `package:raml` — Packages the RAML artifact
+- **Spectral ruleset** — Created minimal `.spectral.yml` ruleset to make the existing Spectral lint step functional (previously failing silently due to missing ruleset).
+- **OpenAPI JSON endpoint** — Added `/api/swagger.json` endpoint to `server/app.js` to serve the raw merged OpenAPI spec as JSON, enabling programmatic access.
+
+### Changed
+
+- **Dependencies added** — `archiver` (^7.0.1) for creating tar.gz archives.
+
+---
+
+## [1.7.0] - 2026-05-21
+
+### Added
+
+#### Swagger UI & OpenAPI 3.1 Documentation
+
+- **Swagger UI at `/api/swagger`** — Interactive API documentation served via `swagger-ui-express`; publicly accessible with a custom authentication banner (`public/swagger-auth-banner.js`) that explains the cookie-based + CSRF-token authentication flow for testing endpoints directly in the browser.
+- **OpenAPI 3.1 specification** — Central `server/openapi.yaml` file containing base metadata, security schemes (`CookieAuth`, `CsrfToken`), and reusable component schemas:
+  - `NormalizedDownload` — standardised download object returned by all PDCA clients
+  - `DashboardPayload` — SSE payload shape (`{ user, isAdmin, downloads, downloadClients }`)
+  - `ErrorResponse` — standard error envelope with redacted details
+  - `BlocklistSearchRequest` — payload for the admin blocklist-and-search operation
+  - `WebhookPayload` — Sonarr/Radarr webhook event structure
+  - `HistoryItem` — deduplicated history record with upgrade-availability flag
+  - `StatusResponse` — server metrics, polling timings, cache stats, and webhook metrics
+- **Hybrid documentation approach** — Per-endpoint details are documented directly in route handler files (`server/routes/*.js`) using JSDoc `@openapi` comments. `swagger-jsdoc` merges these comments with the central YAML at runtime, keeping documentation close to the code while maintaining shared schemas in one place.
+- **Comprehensive endpoint coverage** — All implemented endpoints are documented:
+  - Authentication: `POST /api/auth/login`, `GET /api/auth/me`, `GET /api/auth/csrf`, `POST /api/auth/logout`
+  - Dashboard: `GET /api/dashboard/stream` (SSE), `GET /api/dashboard/user-downloads` (deprecated), `GET /api/dashboard/cover-art`, `POST /api/dashboard/blocklist-search`
+  - Status: `GET /api/status`
+  - History: `GET /api/history/recent`
+  - Webhooks: `POST /api/webhook/sonarr`, `POST /api/webhook/radarr`
+  - Proxy routes: Sonarr, Radarr, SABnzbd, and Emby authenticated proxies
+  - Public health: `GET /health`, `GET /ready`
+- **Machine-usable extensions** — Every documented endpoint includes:
+  - `x-code-samples` with cURL, JavaScript fetch, and TypeScript examples
+  - `x-integration-notes` section in descriptions for AI agents and automated tooling
+  - Realistic request/response examples and full JSON Schema definitions
+- **Coverage validation test suite** — `tests/integration/swagger-coverage.test.js` (22 tests) validates that:
+  - The OpenAPI spec loads without YAML parse errors
+  - Every Express route appears in the merged spec
+  - All schema and response examples are valid JSON
+  - Required security schemes (`CookieAuth`, `CsrfToken`) are defined and referenced correctly
+  - The Swagger UI HTML endpoint (`GET /api/swagger`) returns `200`
+- **CI/CD validation job** — Added "Swagger Validation & Coverage" job in `.gitea/workflows/ci.yml` that runs on every push:
+  - Lints `server/openapi.yaml` with `@stoplight/spectral-cli`
+  - Runs `npm test -- tests/integration/swagger-coverage.test.js` to verify coverage
+
+### Changed
+
+- **Dependencies added** — `swagger-ui-express` (^5.0.1), `swagger-jsdoc` (^6.2.8), `yamljs` (^0.3.0), and `@stoplight/spectral-cli` (^6.16.0 dev dependency) for OpenAPI generation, UI serving, and spec linting.
+
+### Security
+
+- **Swagger UI public access** — The Swagger UI endpoint (`/api/swagger`) is publicly accessible by design for convenience. All documented API endpoints still enforce authentication (`emby_user` cookie) and CSRF protection (`X-CSRF-Token` header for mutations) as before. The authentication banner in the UI explicitly instructs users to log in via `POST /api/auth/login` first before testing protected endpoints.
+
+---
+
+## [1.6.0] - 2026-05-21
+
+### Added
+
+- **Staged history loading with SSE push** — history data from Sonarr/Radarr is now fetched in stages; `history-update` SSE events push incremental results to the dashboard so the "Recently Completed" tab populates without waiting for the full fetch.
+- **Frontend unit tests** — added Vitest + jsdom test suite covering `client/src/` modules (formatters, storage, state).
+- **Comprehensive tests for staged history loading** — backend tests verify the new background-fetch behaviour, cache TTL handling, and SSE emission.
+- **Integration test coverage** — new integration and unit tests for `dashboard`, `emby`, `sonarr`, `radarr`, and `sabnzbd` routes.
+
+### Changed
+
+- **Technical-debt remediation — service extraction** — extracted matching and assembly logic from the monolithic `dashboard.js` (~1,360 lines → ~284 lines) into dedicated, testable services:
+  - `DownloadMatcher.js` — SABnzbd slot / torrent → *arr record matching
+  - `DownloadAssembler.js` — cover-art, episode, link, blocklist-eligibility helpers
+  - `DownloadBuilder.js` — orchestrator that reads the cache snapshot and builds the final user-facing download list
+  - `TagMatcher.js` — tag extraction, sanitisation, and user-ownership matching
+  - `WebhookStatus.js` — webhook configuration status aggregation
+- **Frontend architecture** — migrated from a monolithic `public/app.js` to vanilla ES modules under `client/src/`, bundled by Vite into `public/app.js`.
+- **History pagination** — replaced custom date-based cursor pagination with the retriever's built-in pagination (`pageSize=100`, up to 10 pages / 1,000 records total). Eliminates the 40-second response-time regression seen with large histories.
+- **Status endpoint path** — admin status route moved from `/api/status/status` to `/api/status` for consistency with the router mount point.
+- **Background-fetch safety** — the poller no longer overwrites the cache with empty data when a background history fetch fails or returns no records.
+- **SABnzbd progress calculation** — progress is now computed from `slot.mb` and `slot.mbleft` / `slot.mbmissing` because the SABnzbd queue API does not expose a `percentage` field.
+- **Speed formatting consistency** — `updateDownloadCard()` now calls `formatSpeed()` so all speed values display with uniform units (B/s, KB/s, MB/s, GB/s).
+- **Status-panel error handling** — the panel now surfaces error messages (e.g. `403` for non-admin users) instead of showing a blank box.
+
+### Fixed
+
+- **CSRF token reference errors** — fixed `ReferenceError` bugs in `api.js`, `auth.js`, and the blocklist handler where `csrfToken` and `currentUser` were accessed as bare variables instead of via the shared `state` object.
+- **Logout button** — fixed undefined variable references in `handleLogoutClick` that prevented the logout flow from completing.
+- **Missing progress bar for SABnzbd** — SABnzbd downloads now render a correct progress bar instead of showing `undefined%`.
+- **Status route 404** — corrected the Express router mount so `GET /api/status` responds instead of returning HTML 404.
+- **Status button DOM ID** — fixed element-ID mismatch (`status-btn` vs `status-toggle`) that prevented the admin status button from toggling the panel.
+- **Tab selection** — fixed tab switching to use `data-tab` attributes after the DOM IDs were removed during the ES-module migration.
+- **CSP violations and `ignoreAvailable` reference error** — resolved frontend CSP compliance issues and a missing-variable error in the history tab.
+- **Docker client-build stage** — removed `client/` from `.dockerignore` so the multi-stage Dockerfile can run the Vite build during image creation.
+- **Unmatched torrent exclusion** — torrents that cannot be matched to a Sonarr/Radarr record are now correctly omitted from the download display.
+- **Blocklist button CSRF** — fixed a `ReferenceError` that occurred when a non-admin user clicked the blocklist button.
+
+### Breaking Changes
+
+- **Unmatched torrents are no longer displayed** — torrents that do not match a Sonarr/Radarr queue or history record are excluded from the dashboard. Users who previously saw direct torrent-client downloads will no longer see them unless the *arr services track the item.
+- **Frontend build process changed** — the monolithic `public/app.js` source file has been replaced by a Vite build from `client/src/`. Any custom deployment scripts that copy or modify `public/app.js` directly must be updated to run `npm run build` (or use the provided Dockerfile, which already does this).
+- **Status API endpoint path changed** — the admin status endpoint moved from `/api/status/status` to `/api/status`. External integrations, monitoring checks, or scripts hitting the old path will receive `404`.
+
+---
+
+## [1.5.5] - 2026-05-20
+
+### Added
+
+- **Download client logos** — Added SVG logos for all supported download clients (SABnzbd, qBittorrent, Transmission, rTorrent, Deluge). Logos appear in the download client filter picker and on download cards.
+- **Download client logo in filter picker** — Multi-select download client filter now displays client logos alongside names for visual identification.
+- **Download client logo in download cards** — Download cards now display the client logo in the bottom-right corner (32×32px). Positioned absolutely within the card.
+- **SABnzbd speed display** — SABnzbd downloads now display the overall queue speed for the currently active download only. Speed is fetched from the client status API and applied to the downloading slot.
+- **Speed formatting** — Speed values are now formatted with appropriate units (B/s, KB/s, MB/s, GB/s) instead of raw bytes.
+
+### Fixed
+
+- **Missing pieces display for SABnzbd** — Removed incorrect "missing x of y" text display for SABnzbd downloads. This information is only relevant for torrent clients (qBittorrent, rTorrent) and is now only shown for those clients.
+- **Logo duplication on page reload** — Fixed download client logos and user tags appearing twice during page load. Updated `updateDownloadCard()` to remove old elements before adding new ones.
+- **Logo positioning** — Fixed download client logos appearing stacked at bottom-right of browser window instead of bottom-right of each card. Added `position: relative` to `.download-card` to provide proper positioning context.
+
+---
+
+## [1.5.4] - 2026-05-19
+
+### Added
+
+- **Multi-select download client filter** — Active Downloads tab now includes a dropdown filter that allows users to select multiple download clients. Shows client name and type (e.g., "Main (qbitt)"). Includes Select All / Deselect All buttons. Selection persists across sessions via localStorage.
+- **Download client ordering** — Downloads are now sorted by client order (matching the configuration order). Downloads from the first configured client appear first.
+- **Client metadata in downloads** — Download objects now include `client`, `instanceId`, and `instanceName` fields for client identification and filtering.
+- **SSE payload extension** — SSE stream now includes `downloadClients` array with all configured clients for UI ordering/filtering.
+- **Automatic migration** — Existing single-select filter selection automatically migrates to new multi-select format on first load.
+
+### Fixed
+
+- **SABnzbd size and speed display** — Fixed SABnzbd downloads showing undefined size and speed values. Now correctly uses `slot.mb` for size calculation and `slot.kbpersec` for per-slot speed from cached data.
 
 ---
 

Dockerfile

@@ -9,6 +9,18 @@ WORKDIR /app
 COPY package.json package-lock.json ./
 RUN npm ci --omit=dev
 
+# ---------------------------------------------------------------------------
+# Stage 1.5 — client-build: build frontend with Vite
+# ---------------------------------------------------------------------------
+FROM node:22-alpine AS client-build
+
+WORKDIR /app/client
+
+COPY client/package.json client/package-lock.json ./
+RUN npm ci
+COPY client/ ./
+RUN npm run build
+
 # ---------------------------------------------------------------------------
 # Stage 2 — runtime image (minimal attack surface)
 # ---------------------------------------------------------------------------
@@ -33,6 +45,7 @@ COPY --from=deps /app/node_modules ./node_modules
 # Copy application source owned by root (read-only at runtime)
 COPY --chown=root:root server/ ./server/
 COPY --chown=root:root public/ ./public/
+COPY --from=client-build --chown=root:root /app/public/ ./public/
 COPY --chown=root:root package.json ./
 # Bundled snakeoil certificate for out-of-the-box TLS (self-signed, localhost only).
 # Mount your own cert/key over /app/certs/ or set TLS_CERT/TLS_KEY env vars.

README.md

@@ -4,7 +4,7 @@
 
 **sofarr** is a personal media download dashboard that aggregates and displays real-time download progress from all your media automation services. Named for the experience of checking what has downloaded "so far" while you wait comfortably on your "sofa" for Sonarr, Radarr, and your download clients to do their thing!
 
-Version 1.5.x adds **real-time webhook integration**: Sonarr and Radarr can push events directly to sofarr, eliminating polling latency and automatically reducing background API calls when webhooks are active.
+Version 1.7.x adds **interactive Swagger UI and OpenAPI 3.1 documentation** at `/api/swagger` — explore, test, and integrate with the full API using a hybrid YAML + JSDoc documentation system.
 
 ## What It Does
 
@@ -93,6 +93,7 @@ SONARR_INSTANCES=[{"name":"main","url":"...","apiKey":"..."}]
 - Sonarr (optional, for TV tracking)
 - Radarr (optional, for movie tracking)
 - Emby (for user authentication)
+- Ombi (optional, for request management integration)
 
 ## Docker Deployment (Recommended)
 
@@ -226,6 +227,10 @@ PORT=3001                           # Server port
 LOG_LEVEL=info                      # Logging: debug, info, warn, error, silent
 POLL_INTERVAL=5000                  # Background polling interval in ms (default: 5000)
                                     # Set to 0 or "off" to disable (on-demand mode)
+
+# Debug Log Streaming Subsystem
+ENABLE_LOG_STREAM=false             # Set to true to enable logs debugging routes
+LOG_ALLOW_SUBNETS=127.0.0.1/32      # Comma-separated allowed CIDR blocks (e.g. 127.0.0.1/32,192.168.1.0/24)
 ```
 
 ### Webhooks & Smart Polling
@@ -305,6 +310,31 @@ RTORRENT_USERNAME=rtorrent
 RTORRENT_PASSWORD=rtorrent
 ```
 
+### Ombi Integration (Optional)
+
+sofarr integrates with Ombi for request management, allowing downloads to be linked to their originating Ombi requests. This provides direct access to request details and enables seamless navigation between downloads and requests.
+
+**Configuration:**
+```bash
+# JSON array format (recommended for multiple instances)
+OMBI_INSTANCES=[{"name":"main","url":"https://ombi.example.com","apiKey":"your-ombi-api-key"}]
+
+# Legacy single-instance format
+OMBI_URL=https://ombi.example.com
+OMBI_API_KEY=your-ombi-api-key
+```
+
+**Features & Architecture:**
+- **Request Filtering & Search**: Retrieve, search, and filter requests in real-time by status (pending, approved, available, denied), media type (movies, TV shows), or name.
+- **Dual-Layer Filtering & Persistence**: search and core filters are handled server-side for speed and efficiency, while responsive client-side refinements handle on-the-fly rendering. User filter preferences are persisted locally/session-wide to ensure a consistent experience across page refreshes.
+- **Real-Time SSE Updates**: Integrates with the Server-Sent Events (SSE) push stream. When requests are created or updated, the dashboard is instantly notified without client-side polling.
+- **External ID Matching**: Downloads are matched to Ombi requests using external IDs (TMDB, TVDB, IMDB).
+  - **TV Shows**: TVDB ID (primary) → TMDB ID (fallback)
+  - **Movies**: TMDB ID (primary) → IMDB ID (fallback)
+  - Matching is performed automatically using data from Sonarr/Radarr.
+- **Interactive UI**: When a matching request is found, an Ombi icon appears in the download card to open the request page. If no request exists, a search link is provided instead.
+- **Fully Optional**: Integration is fully optional — sofarr works perfectly without Ombi configured.
+
 ## Setting Up User Tags
 
 To see your downloads, you need to tag your media in Sonarr/Radarr:
@@ -353,6 +383,49 @@ sofarr polls all configured services in the background and caches the results. D
 - **Peers** - Number of peers
 - **Availability** - Percentage available in swarm (shown in red when below 100%)
 
+## API Documentation (Swagger UI)
+
+sofarr provides interactive API documentation via Swagger UI, available at:
+
+**`http://your-server:3001/api/swagger`**
+
+### Authentication in Swagger UI
+
+sofarr uses cookie-based authentication with Emby/Jellyfin. To test authenticated endpoints in Swagger UI:
+
+1. **Login via Swagger UI:**
+   - Expand `POST /api/auth/login`
+   - Click "Try it out"
+   - Enter your Emby username and password
+   - Click "Execute"
+   - The browser will automatically save the session cookies
+
+2. **For state-changing requests (POST/PUT/PATCH/DELETE):**
+   - Swagger UI automatically includes the `X-CSRF-Token` header from your cookies
+   - No manual header configuration needed
+
+3. **For GET requests:**
+   - Cookies are sent automatically
+   - No additional configuration needed
+
+### Hybrid Documentation Approach
+
+sofarr uses a hybrid documentation model to maintain clean, maintainable API documentation:
+
+- **Central OpenAPI Specification (`server/openapi.yaml`)**: Contains base metadata, security schemes, component schemas (NormalizedDownload, DashboardPayload, ErrorResponse, etc.), and path definitions. This is the single source of truth for shared data structures and global configuration.
+
+- **JSDoc `@openapi` Comments in Route Files**: Per-endpoint details are documented directly in the route handler files (`server/routes/*.js`) using JSDoc `@openapi` comments. swagger-jsdoc merges these comments with the central YAML at runtime, keeping documentation close to the code while maintaining a clean separation of concerns.
+
+This approach provides:
+- **Maintainability**: Endpoint details live alongside the code they document
+- **Consistency**: Shared schemas are defined once in the central YAML
+- **Flexibility**: Easy to update documentation when code changes
+- **Machine-Usability**: Full JSON Schema with realistic examples, code samples, and integration notes for AI agents and automated tools
+
+### Proxy Routes
+
+The proxy routes (`/api/sonarr/**`, `/api/radarr/**`, `/api/sabnzbd/**`, `/api/emby/**) are authenticated proxies to upstream services. These expose a **selective subset** of endpoints from Sonarr, Radarr, SABnzbd, and Emby respectively — not the full upstream API surface. See the API Endpoints section below for the complete list of implemented proxy endpoints.
+
 ## API Endpoints
 
 ### Authentication
@@ -372,11 +445,19 @@ sofarr polls all configured services in the background and caches the results. D
 ### History
 - `GET /api/history/recent` — Recently completed downloads from Sonarr/Radarr history
 
+### Debug Logs (requires ENABLE_LOG_STREAM=true)
+- `GET /api/debug/status` — Get runtime log stream configurations (public)
+- `GET /api/debug/server-logs` — **SSE stream**: push server `stdout`/`stderr` in real-time (requires auth & subnet check)
+- `GET /api/debug/client-logs` — **SSE stream**: push ingested frontend console logs in real-time (requires auth & subnet check)
+- `POST /api/debug/client-logs` — Ingest batched frontend console logs (requires auth & subnet check)
+
 ### Webhook Receiver (no user auth — protected by `X-Sofarr-Webhook-Secret`)
 - `POST /api/webhook/sonarr` — receive Sonarr webhook events
 - `POST /api/webhook/radarr` — receive Radarr webhook events
+- `POST /api/webhook/ombi` — receive Ombi webhook events
 
 ### Webhook Management (requires auth + CSRF)
+- `GET /api/webhook/config` — get webhook configuration status
 - `GET /api/sonarr/api/v3/notification` — list Sonarr notification connections
 - `POST /api/sonarr/api/v3/notification` — create/update Sonarr notification connection
 - `GET /api/radarr/api/v3/notification` — list Radarr notification connections
@@ -385,12 +466,44 @@ sofarr polls all configured services in the background and caches the results. D
 - `POST /api/radarr/webhook/enable` — one-click enable Sofarr webhook in Radarr
 - `POST /api/sonarr/webhook/test` — trigger a Sonarr test event
 - `POST /api/radarr/webhook/test` — trigger a Radarr test event
+- `GET /api/ombi/webhook/status` — get Ombi webhook status and metrics
+- `POST /api/ombi/webhook/enable` — one-click enable Sofarr webhook in Ombi
+- `POST /api/ombi/webhook/test` — trigger an Ombi test event
+
+### Ombi (requires auth)
+- `GET /api/ombi/requests` — get Ombi requests with server-side filtering, search, and sorting
 
 ### Service APIs (proxy to your services)
-- `GET /api/sabnzbd/*` — SABnzbd API proxy
-- `GET /api/sonarr/*` — Sonarr API proxy
-- `GET /api/radarr/*` — Radarr API proxy
-- `GET /api/emby/*` — Emby API proxy
+- `GET /api/sabnzbd/queue` — SABnzbd queue
+- `GET /api/sabnzbd/history` — SABnzbd history
+- `GET /api/sonarr/queue` — Sonarr queue
+- `GET /api/sonarr/history` — Sonarr history
+- `GET /api/sonarr/series` — Sonarr series list
+- `GET /api/sonarr/series/:id` — Sonarr series details
+- `GET /api/sonarr/notifications` — Sonarr notifications list
+- `GET /api/sonarr/notifications/:id` — Sonarr notification details
+- `POST /api/sonarr/notifications` — Create Sonarr notification
+- `PUT /api/sonarr/notifications/:id` — Update Sonarr notification
+- `DELETE /api/sonarr/notifications/:id` — Delete Sonarr notification
+- `POST /api/sonarr/notifications/test` — Test Sonarr notification
+- `GET /api/sonarr/notifications/schema` — Sonarr notification schema
+- `POST /api/sonarr/notifications/sofarr-webhook` — One-click Sofarr webhook setup
+- `GET /api/radarr/queue` — Radarr queue
+- `GET /api/radarr/history` — Radarr history
+- `GET /api/radarr/movies` — Radarr movies list
+- `GET /api/radarr/movies/:id` — Radarr movie details
+- `GET /api/radarr/notifications` — Radarr notifications list
+- `GET /api/radarr/notifications/:id` — Radarr notification details
+- `POST /api/radarr/notifications` — Create Radarr notification
+- `PUT /api/radarr/notifications/:id` — Update Radarr notification
+- `DELETE /api/radarr/notifications/:id` — Delete Radarr notification
+- `POST /api/radarr/notifications/test` — Test Radarr notification
+- `GET /api/radarr/notifications/schema` — Radarr notification schema
+- `POST /api/radarr/notifications/sofarr-webhook` — One-click Sofarr webhook setup
+- `GET /api/emby/sessions` — Emby active sessions
+- `GET /api/emby/users` — Emby users list
+- `GET /api/emby/users/:id` — Emby user details
+- `GET /api/emby/session/:sessionId/user` — Emby user from session
 
 ## Logging Levels
 
@@ -429,7 +542,7 @@ npm run test:coverage   # with V8 coverage report (outputs to coverage/)
 npm run test:ui         # interactive Vitest UI
 ```
 
-290 tests across 18 test files covering auth middleware, CSRF protection, secret sanitization, config parsing, token store, qBittorrent utilities, history deduplication/classification, download client architecture, webhook endpoint security, input validation, replay protection, and webhook metrics integration. See [`tests/README.md`](tests/README.md) for design decisions and coverage targets.
+Over 830 tests across 39 files covering auth middleware, CSRF protection, secret sanitization, config parsing, token store, qBittorrent utilities, history deduplication/classification, download client architecture, webhook endpoint security, input validation, replay protection, webhook metrics integration, polling retrievers, and Ombi filter/search logic. See [`tests/README.md`](tests/README.md) for design decisions and coverage targets.
 
 ## Development
 

SECURITY.md

@@ -4,9 +4,12 @@
 
 | Version | Supported |
 |---------|-----------|
-| 1.4.x   | ✅ Yes    |
-| 1.3.x   | ✅ Yes    |
-| 1.2.x   | ✅ Yes    |
+| 1.7.x   | ✅ Yes    |
+| 1.6.x   | ✅ Yes    |
+| 1.5.x   | ✅ Yes    |
+| 1.4.x   | ❌ No     |
+| 1.3.x   | ❌ No     |
+| 1.2.x   | ❌ No     |
 | 1.1.x   | ❌ No     |
 | 1.0.x   | ❌ No     |
 | < 1.0   | ❌ No     |
@@ -37,10 +40,13 @@ users via Emby. The primary threat surface when exposed to the public internet:
 | Privilege escalation (container) | Non-root user (UID 1000), `no-new-privileges`, all caps dropped |
 | Unbounded log growth | Size-based rotation: 10 MB cap, 3 rotated files kept |
 | Dependency vulnerabilities | `npm audit --audit-level=high` in CI on every push |
-| Unauthorized webhook injection | `SOFARR_WEBHOOK_SECRET` required on `X-Sofarr-Webhook-Secret` header; 401 on mismatch |
+| Unauthorized webhook injection | `SOFARR_WEBHOOK_SECRET` required on `X-Sofarr-Webhook-Secret` header or `secret` query parameter; 401 on mismatch |
 | Webhook payload injection | `validatePayload()` allowlists 18 known event types; rejects non-object bodies and overlong fields |
 | Webhook replay attacks | `isReplay()` tracks `(eventType, instanceName, date)` tuples for 5 minutes; duplicate events return `200 { duplicate: true }` without cache mutation |
 | Webhook flood / DoS | Dedicated rate limiter: 60 requests/min per IP on `/api/webhook/*` |
+| API documentation disclosure | Swagger UI at `/api/swagger` publicly exposes endpoint structure; mitigated by endpoint auth requirements and CSRF protection on all mutations |
+| Ombi API key exposure | API keys stored in environment variables, never logged; `sanitizeError()` redacts Ombi credentials; Ombi retriever uses 5-minute cache to minimize API calls |
+| Ombi rate limit exhaustion | Ombi retriever includes 5-minute TTL cache to reduce API call frequency; graceful degradation if Ombi is unavailable |
 
 ---
 
@@ -156,11 +162,13 @@ server {
 
 ## Rate Limits
 
-| Endpoint | Limit |
-|----------|-------|
-| `POST /api/auth/login` | 10 failed attempts per 15 min per IP |
-| All `/api/*` routes | 300 requests per 15 min per IP |
-| `POST /api/webhook/*` | 60 requests per 1 min per IP (webhook-specific limiter, stricter than general) |
+| Endpoint | Limit | Details & Exemptions |
+|----------|-------|----------------------|
+| `POST /api/auth/login` | 10 attempts per 15 min per IP | **Only failed attempts count** (`skipSuccessfulRequests: true`). Successful requests are not counted. |
+| All `/api/*` routes | 300 requests per 15 min per IP | General rate limiting. **Exempts `/api/dashboard/cover-art` requests** to avoid page layout image loading exhaustion. |
+| `POST /api/webhook/*` | 60 requests per 1 min per IP | Webhook-specific limiter, stricter than general. |
+| `/health` and `/ready` | Exempt | Root-level liveness/readiness probes bypass rate limiters completely. |
+| `GET /api/swagger` | Exempt | Public Swagger UI documentation does not enforce rate limits. |
 
 ---
 

client/index.html

@@ -7,6 +7,6 @@
   </head>
   <body>
     <div id="root"></div>
-    <script type="module" src="/src/main.jsx"></script>
+    <script type="module" src="/src/main.js"></script>
   </body>
 </html>

client/src/App.css

@@ -1,499 +0,0 @@
-* {
-  margin: 0;
-  padding: 0;
-  box-sizing: border-box;
-}
-
-body {
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-    sans-serif;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-  min-height: 100vh;
-}
-
-.app {
-  min-height: 100vh;
-  padding: 20px;
-  max-width: 1200px;
-  margin: 0 auto;
-}
-
-.app-header {
-  background: white;
-  padding: 30px;
-  border-radius: 10px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-  margin-bottom: 20px;
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: 20px;
-}
-
-.app-header h1 {
-  color: #333;
-  font-size: 2rem;
-}
-
-.user-info {
-  display: flex;
-  align-items: center;
-  gap: 10px;
-  background: #f0f0f0;
-  padding: 10px 20px;
-  border-radius: 20px;
-}
-
-.user-label {
-  color: #666;
-  font-weight: 500;
-}
-
-.user-name {
-  color: #667eea;
-  font-weight: bold;
-  font-size: 1.1rem;
-}
-
-.controls {
-  background: white;
-  padding: 20px;
-  border-radius: 10px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-  margin-bottom: 20px;
-  display: flex;
-  gap: 15px;
-  align-items: center;
-  flex-wrap: wrap;
-}
-
-.controls label {
-  color: #333;
-  font-weight: 500;
-}
-
-.session-select {
-  flex: 1;
-  min-width: 200px;
-  padding: 10px;
-  border: 2px solid #e0e0e0;
-  border-radius: 5px;
-  font-size: 1rem;
-  cursor: pointer;
-}
-
-.session-select:focus {
-  outline: none;
-  border-color: #667eea;
-}
-
-.refresh-btn {
-  padding: 10px 20px;
-  background: #667eea;
-  color: white;
-  border: none;
-  border-radius: 5px;
-  cursor: pointer;
-  font-size: 1rem;
-  transition: background 0.3s;
-}
-
-.refresh-btn:hover {
-  background: #5568d3;
-}
-
-.error-message {
-  background: #fee;
-  color: #c33;
-  padding: 15px;
-  border-radius: 10px;
-  margin-bottom: 20px;
-  border-left: 4px solid #c33;
-}
-
-.loading {
-  text-align: center;
-  padding: 40px;
-  color: white;
-  font-size: 1.2rem;
-}
-
-.downloads-container {
-  background: white;
-  padding: 30px;
-  border-radius: 10px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-
-.downloads-container h2 {
-  color: #333;
-  margin-bottom: 20px;
-  font-size: 1.5rem;
-}
-
-.no-downloads {
-  text-align: center;
-  padding: 40px;
-  color: #666;
-}
-
-.no-downloads p {
-  margin: 10px 0;
-}
-
-.downloads-list {
-  display: grid;
-  gap: 20px;
-}
-
-.download-card {
-  border: 2px solid #e0e0e0;
-  border-radius: 10px;
-  padding: 20px;
-  transition: transform 0.2s, box-shadow 0.2s;
-  display: flex;
-  gap: 20px;
-  align-items: flex-start;
-}
-
-.download-cover {
-  flex-shrink: 0;
-  width: 80px;
-  border-radius: 6px;
-  overflow: hidden;
-  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
-}
-
-.download-cover img {
-  width: 100%;
-  height: auto;
-  display: block;
-}
-
-.download-info {
-  flex: 1;
-  min-width: 0;
-}
-
-.download-card:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 6px 12px rgba(0, 0, 0, 0.1);
-}
-
-.download-card.series {
-  border-left: 4px solid #667eea;
-}
-
-.download-card.movie {
-  border-left: 4px solid #f093fb;
-}
-
-.download-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 15px;
-}
-
-.download-type {
-  padding: 5px 15px;
-  border-radius: 20px;
-  font-size: 0.9rem;
-  font-weight: 500;
-}
-
-.download-type.series {
-  background: #e8eaf6;
-  color: #667eea;
-}
-
-.download-type.movie {
-  background: #fce4ec;
-  color: #f093fb;
-}
-
-.download-status {
-  padding: 5px 15px;
-  border-radius: 20px;
-  font-size: 0.9rem;
-  font-weight: 500;
-  text-transform: capitalize;
-}
-
-.download-status.downloading {
-  background: #e8f5e9;
-  color: #4caf50;
-}
-
-.download-status.completed {
-  background: #e3f2fd;
-  color: #2196f3;
-}
-
-.download-status.failed {
-  background: #ffebee;
-  color: #f44336;
-}
-
-.download-title {
-  color: #333;
-  margin-bottom: 10px;
-  font-size: 1.2rem;
-}
-
-.download-series,
-.download-movie {
-  color: #666;
-  margin-bottom: 15px;
-  font-style: italic;
-}
-
-.download-details {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-  gap: 15px;
-  padding-top: 15px;
-  border-top: 1px solid #e0e0e0;
-}
-
-.detail-item {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-}
-
-.detail-label {
-  color: #999;
-  font-size: 0.85rem;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-}
-
-.detail-value {
-  color: #333;
-  font-weight: 500;
-}
-
-.app-footer {
-  margin-top: 20px;
-  text-align: center;
-  color: white;
-  font-size: 0.9rem;
-}
-
-.app-footer p {
-  opacity: 0.9;
-}
-
-@media (max-width: 768px) {
-  .app-header {
-    flex-direction: column;
-    align-items: flex-start;
-  }
-
-  .controls {
-    flex-direction: column;
-    align-items: stretch;
-  }
-
-  .download-details {
-    grid-template-columns: 1fr;
-  }
-}
-
-/* Webhooks Section Styles */
-.webhooks-section {
-  background: white;
-  border-radius: 10px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-  margin-bottom: 20px;
-  overflow: hidden;
-}
-
-.webhooks-header {
-  padding: 20px 30px;
-  background: #f8f9fa;
-  border-bottom: 2px solid #e0e0e0;
-  cursor: pointer;
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  transition: background 0.3s;
-}
-
-.webhooks-header:hover {
-  background: #f0f1f2;
-}
-
-.webhooks-header h2 {
-  color: #333;
-  font-size: 1.3rem;
-  margin: 0;
-}
-
-.webhooks-toggle {
-  font-size: 1.2rem;
-  color: #666;
-  transition: transform 0.3s;
-}
-
-.webhooks-toggle.expanded {
-  transform: rotate(180deg);
-}
-
-.webhooks-content {
-  padding: 20px 30px;
-}
-
-.webhook-instance {
-  padding: 20px 0;
-  border-bottom: 1px solid #e0e0e0;
-}
-
-.webhook-instance:last-child {
-  border-bottom: none;
-}
-
-.webhook-instance h3 {
-  color: #333;
-  font-size: 1.1rem;
-  margin-bottom: 15px;
-}
-
-.webhook-status {
-  display: flex;
-  align-items: center;
-  gap: 15px;
-  margin-bottom: 15px;
-}
-
-.status-indicator {
-  font-size: 1rem;
-  font-weight: 500;
-  padding: 5px 15px;
-  border-radius: 20px;
-}
-
-.status-indicator.enabled {
-  background: #e8f5e9;
-  color: #4caf50;
-}
-
-.status-indicator.disabled {
-  background: #f5f5f5;
-  color: #999;
-}
-
-.enable-webhook-btn {
-  padding: 8px 16px;
-  background: #667eea;
-  color: white;
-  border: none;
-  border-radius: 5px;
-  cursor: pointer;
-  font-size: 0.95rem;
-  transition: background 0.3s;
-}
-
-.enable-webhook-btn:hover {
-  background: #5568d3;
-}
-
-.enable-webhook-btn:disabled {
-  background: #ccc;
-  cursor: not-allowed;
-}
-
-.test-webhook-btn {
-  padding: 8px 16px;
-  background: #f093fb;
-  color: white;
-  border: none;
-  border-radius: 5px;
-  cursor: pointer;
-  font-size: 0.95rem;
-  transition: background 0.3s;
-}
-
-.test-webhook-btn:hover {
-  background: #d97ed8;
-}
-
-.test-webhook-btn:disabled {
-  background: #ccc;
-  cursor: not-allowed;
-}
-
-.webhook-triggers {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-  gap: 10px;
-  padding-top: 15px;
-  border-top: 1px solid #e0e0e0;
-}
-
-.trigger-item {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-}
-
-.trigger-label {
-  color: #666;
-  font-size: 0.9rem;
-}
-
-.trigger-value {
-  font-weight: 500;
-  font-size: 1.1rem;
-}
-
-.trigger-value.active {
-  color: #4caf50;
-}
-
-.trigger-value.inactive {
-  color: #999;
-}
-
-.webhook-stats {
-  margin-top: 15px;
-  padding-top: 15px;
-  border-top: 1px solid #e0e0e0;
-}
-
-.webhook-stats-title {
-  color: #999;
-  font-size: 0.75rem;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.6px;
-  margin-bottom: 10px;
-}
-
-.webhook-stats-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
-  gap: 10px;
-}
-
-.webhook-stat {
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
-}
-
-.webhook-stat-label {
-  color: #999;
-  font-size: 0.8rem;
-}
-
-.webhook-stat-value {
-  color: #333;
-  font-size: 0.95rem;
-  font-weight: 500;
-}

client/src/App.jsx

@@ -1,483 +0,0 @@
-// Copyright (c) 2026 Gordon Bolton. MIT License.
-import { useState, useEffect } from 'react';
-import axios from 'axios';
-import './App.css';
-
-function App() {
-  const [sessionId, setSessionId] = useState('');
-  const [currentUser, setCurrentUser] = useState(null);
-  const [downloads, setDownloads] = useState([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const [sessions, setSessions] = useState([]);
-  const [webhookSectionExpanded, setWebhookSectionExpanded] = useState(false);
-  const [sonarrWebhook, setSonarrWebhook] = useState({ enabled: false, triggers: { onGrab: false, onDownload: false, onImport: false, onUpgrade: false }, stats: null });
-  const [radarrWebhook, setRadarrWebhook] = useState({ enabled: false, triggers: { onGrab: false, onDownload: false, onImport: false, onUpgrade: false }, stats: null });
-  const [webhookMetrics, setWebhookMetrics] = useState(null);
-  const [webhookLoading, setWebhookLoading] = useState(false);
-
-  useEffect(() => {
-    fetchSessions();
-    fetchWebhookStatus();
-  }, []);
-
-  const fetchSessions = async () => {
-    try {
-      const response = await axios.get('/api/emby/sessions');
-      setSessions(response.data);
-      
-      // Auto-select first active session
-      const activeSession = response.data.find(s => s.NowPlayingItem || s.Active);
-      if (activeSession) {
-        setSessionId(activeSession.Id);
-        fetchUserDownloads(activeSession.Id);
-      }
-    } catch (err) {
-      setError('Failed to fetch Emby sessions. Make sure Emby is running and configured.');
-      console.error(err);
-    }
-  };
-
-  const fetchUserDownloads = async (sessionId) => {
-    setLoading(true);
-    setError(null);
-    try {
-      const response = await axios.get(`/api/dashboard/user-downloads/${sessionId}`);
-      setCurrentUser(response.data.user);
-      setDownloads(response.data.downloads);
-    } catch (err) {
-      setError('Failed to fetch downloads. Make sure all services are configured.');
-      console.error(err);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const handleSessionChange = (e) => {
-    const newSessionId = e.target.value;
-    setSessionId(newSessionId);
-    if (newSessionId) {
-      fetchUserDownloads(newSessionId);
-    }
-  };
-
-  const formatSize = (bytes) => {
-    if (!bytes) return 'N/A';
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(1024));
-    return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
-  };
-
-  const formatDate = (dateString) => {
-    if (!dateString) return 'N/A';
-    return new Date(dateString).toLocaleString();
-  };
-
-  const formatTimeAgo = (timestamp) => {
-    if (!timestamp) return 'Never';
-    const seconds = Math.floor((Date.now() - timestamp) / 1000);
-    if (seconds < 60) return `${seconds}s ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60) return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24) return `${hours}h ago`;
-    return `${Math.floor(hours / 24)}d ago`;
-  };
-
-  const fetchWebhookMetrics = async () => {
-    try {
-      const response = await axios.get('/api/dashboard/webhook-metrics');
-      setWebhookMetrics(response.data);
-      return response.data;
-    } catch (err) {
-      // Not fatal — stats just won't display
-      return null;
-    }
-  };
-
-  const fetchWebhookStatus = async () => {
-    try {
-      // Fetch metrics in parallel with notification status
-      const metricsPromise = fetchWebhookMetrics();
-
-      // Fetch Sonarr notifications
-      let sonarrEnabled = false;
-      let sonarrTriggers = { onGrab: false, onDownload: false, onImport: false, onUpgrade: false };
-      try {
-        const sonarrResponse = await axios.get('/api/sonarr/notifications');
-        const sonarrSofarr = sonarrResponse.data.find(n => n.name === 'Sofarr');
-        sonarrEnabled = !!sonarrSofarr;
-        if (sonarrSofarr) {
-          sonarrTriggers = {
-            onGrab: sonarrSofarr.onGrab,
-            onDownload: sonarrSofarr.onDownload,
-            onImport: sonarrSofarr.onImport,
-            onUpgrade: sonarrSofarr.onUpgrade
-          };
-        }
-      } catch (err) {
-        // Sonarr not configured or not accessible
-      }
-
-      // Fetch Radarr notifications
-      let radarrEnabled = false;
-      let radarrTriggers = { onGrab: false, onDownload: false, onImport: false, onUpgrade: false };
-      try {
-        const radarrResponse = await axios.get('/api/radarr/notifications');
-        const radarrSofarr = radarrResponse.data.find(n => n.name === 'Sofarr');
-        radarrEnabled = !!radarrSofarr;
-        if (radarrSofarr) {
-          radarrTriggers = {
-            onGrab: radarrSofarr.onGrab,
-            onDownload: radarrSofarr.onDownload,
-            onImport: radarrSofarr.onImport,
-            onUpgrade: radarrSofarr.onUpgrade
-          };
-        }
-      } catch (err) {
-        // Radarr not configured or not accessible
-      }
-
-      const metrics = await metricsPromise;
-
-      // Attach per-instance stats from global metrics.
-      // The instances object is keyed by instance URL; we pick the first
-      // sonarr/radarr entry by matching env-configured URLs.
-      const instanceEntries = metrics ? Object.entries(metrics.instances || {}) : [];
-      const sonarrStats = instanceEntries.find(([url]) => url.includes('sonarr'))?.[1] || null;
-      const radarrStats = instanceEntries.find(([url]) => url.includes('radarr'))?.[1] || null;
-
-      setSonarrWebhook({ enabled: sonarrEnabled, triggers: sonarrTriggers, stats: sonarrStats });
-      setRadarrWebhook({ enabled: radarrEnabled, triggers: radarrTriggers, stats: radarrStats });
-    } catch (err) {
-      console.error('Failed to fetch webhook status:', err);
-    }
-  };
-
-  const enableSonarrWebhook = async () => {
-    setWebhookLoading(true);
-    try {
-      await axios.post('/api/sonarr/notifications/sofarr-webhook');
-      await fetchWebhookStatus();
-    } catch (err) {
-      console.error('Failed to enable Sonarr webhook:', err);
-      alert('Failed to enable Sonarr webhook. Check console for details.');
-    } finally {
-      setWebhookLoading(false);
-    }
-  };
-
-  const enableRadarrWebhook = async () => {
-    setWebhookLoading(true);
-    try {
-      await axios.post('/api/radarr/notifications/sofarr-webhook');
-      await fetchWebhookStatus();
-    } catch (err) {
-      console.error('Failed to enable Radarr webhook:', err);
-      alert('Failed to enable Radarr webhook. Check console for details.');
-    } finally {
-      setWebhookLoading(false);
-    }
-  };
-
-  const testSonarrWebhook = async () => {
-    setWebhookLoading(true);
-    try {
-      const sonarrResponse = await axios.get('/api/sonarr/notifications');
-      const sonarrSofarr = sonarrResponse.data.find(n => n.name === 'Sofarr');
-      if (sonarrSofarr) {
-        await axios.post('/api/sonarr/notifications/test', { id: sonarrSofarr.id });
-        await fetchWebhookStatus();
-        alert('Sonarr webhook test sent successfully!');
-      } else {
-        alert('Sofarr webhook not configured for Sonarr.');
-      }
-    } catch (err) {
-      console.error('Failed to test Sonarr webhook:', err);
-      alert('Failed to test Sonarr webhook. Check console for details.');
-    } finally {
-      setWebhookLoading(false);
-    }
-  };
-
-  const testRadarrWebhook = async () => {
-    setWebhookLoading(true);
-    try {
-      const radarrResponse = await axios.get('/api/radarr/notifications');
-      const radarrSofarr = radarrResponse.data.find(n => n.name === 'Sofarr');
-      if (radarrSofarr) {
-        await axios.post('/api/radarr/notifications/test', { id: radarrSofarr.id });
-        await fetchWebhookStatus();
-        alert('Radarr webhook test sent successfully!');
-      } else {
-        alert('Sofarr webhook not configured for Radarr.');
-      }
-    } catch (err) {
-      console.error('Failed to test Radarr webhook:', err);
-      alert('Failed to test Radarr webhook. Check console for details.');
-    } finally {
-      setWebhookLoading(false);
-    }
-  };
-
-  return (
-    <div className="app">
-      <header className="app-header">
-        <h1>Media Download Dashboard</h1>
-        {currentUser && (
-          <div className="user-info">
-            <span className="user-label">Current User:</span>
-            <span className="user-name">{currentUser}</span>
-          </div>
-        )}
-      </header>
-
-      <div className="controls">
-        <label htmlFor="session-select">Select Emby Session:</label>
-        <select 
-          id="session-select"
-          value={sessionId} 
-          onChange={handleSessionChange}
-          className="session-select"
-        >
-          <option value="">-- Select Session --</option>
-          {sessions.map(session => (
-            <option key={session.Id} value={session.Id}>
-              {session.UserName} - {session.Client} {session.NowPlayingItem ? `(Playing: ${session.NowPlayingItem.Name})` : '(Idle)'}
-            </option>
-          ))}
-        </select>
-        <button onClick={fetchSessions} className="refresh-btn">Refresh Sessions</button>
-      </div>
-
-      {error && (
-        <div className="error-message">
-          {error}
-        </div>
-      )}
-
-      {loading && (
-        <div className="loading">Loading downloads...</div>
-      )}
-
-      {!loading && !error && (
-        <div className="downloads-container">
-          <h2>Your Downloads</h2>
-          {downloads.length === 0 ? (
-            <div className="no-downloads">
-              <p>No downloads found for your user.</p>
-              <p>Make sure your shows and movies are tagged with "user:yourusername" in Sonarr/Radarr.</p>
-            </div>
-          ) : (
-            <div className="downloads-list">
-              {downloads.map((download, index) => (
-                <div key={index} className={`download-card ${download.type}`}>
-                  {download.coverArt && (
-                    <div className="download-cover">
-                      <img src={download.coverArt} alt={download.movieName || download.seriesName || download.title} />
-                    </div>
-                  )}
-                  <div className="download-info">
-                  <div className="download-header">
-                    <span className={`download-type ${download.type}`}>
-                      {download.type === 'series' ? '📺 Series' : '🎬 Movie'}
-                    </span>
-                    <span className={`download-status ${download.status}`}>
-                      {download.status}
-                    </span>
-                  </div>
-                  <h3 className="download-title">{download.title}</h3>
-                  {download.seriesName && (
-                    <p className="download-series">Series: {download.seriesName}</p>
-                  )}
-                  {download.movieName && (
-                    <p className="download-movie">Movie: {download.movieName}</p>
-                  )}
-                  <div className="download-details">
-                    <div className="detail-item">
-                      <span className="detail-label">Size:</span>
-                      <span className="detail-value">{formatSize(download.size)}</span>
-                    </div>
-                    {download.progress && (
-                      <div className="detail-item">
-                        <span className="detail-label">Progress:</span>
-                        <span className="detail-value">{download.progress}%</span>
-                      </div>
-                    )}
-                    {download.speed && (
-                      <div className="detail-item">
-                        <span className="detail-label">Speed:</span>
-                        <span className="detail-value">{download.speed}</span>
-                      </div>
-                    )}
-                    {download.eta && (
-                      <div className="detail-item">
-                        <span className="detail-label">ETA:</span>
-                        <span className="detail-value">{download.eta}</span>
-                      </div>
-                    )}
-                    {download.completedAt && (
-                      <div className="detail-item">
-                        <span className="detail-label">Completed:</span>
-                        <span className="detail-value">{formatDate(download.completedAt)}</span>
-                      </div>
-                    )}
-                  </div>
-                  </div>
-                </div>
-              ))}
-            </div>
-          )}
-        </div>
-      )}
-
-      <div className="webhooks-section">
-        <div className="webhooks-header" onClick={() => setWebhookSectionExpanded(!webhookSectionExpanded)}>
-          <h2>⚡ Webhooks Configuration</h2>
-          <span className={`webhooks-toggle ${webhookSectionExpanded ? 'expanded' : ''}`}>▼</span>
-        </div>
-        {webhookSectionExpanded && (
-          <div className="webhooks-content">
-            {webhookLoading && <div className="loading">Loading webhook status...</div>}
-            <div className="webhook-instance">
-              <h3>Sonarr</h3>
-              <div className="webhook-status">
-                <span className={`status-indicator ${sonarrWebhook.enabled ? 'enabled' : 'disabled'}`}>
-                  {sonarrWebhook.enabled ? '● Enabled' : '○ Disabled'}
-                </span>
-                {!sonarrWebhook.enabled && (
-                  <button onClick={enableSonarrWebhook} className="enable-webhook-btn" disabled={webhookLoading}>
-                    Enable Sofarr Webhooks
-                  </button>
-                )}
-                {sonarrWebhook.enabled && (
-                  <button onClick={testSonarrWebhook} className="test-webhook-btn" disabled={webhookLoading}>
-                    Test
-                  </button>
-                )}
-              </div>
-              {sonarrWebhook.enabled && (
-                <div className="webhook-triggers">
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Grab</span>
-                    <span className={`trigger-value ${sonarrWebhook.triggers.onGrab ? 'active' : 'inactive'}`}>
-                      {sonarrWebhook.triggers.onGrab ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Download</span>
-                    <span className={`trigger-value ${sonarrWebhook.triggers.onDownload ? 'active' : 'inactive'}`}>
-                      {sonarrWebhook.triggers.onDownload ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Import</span>
-                    <span className={`trigger-value ${sonarrWebhook.triggers.onImport ? 'active' : 'inactive'}`}>
-                      {sonarrWebhook.triggers.onImport ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Upgrade</span>
-                    <span className={`trigger-value ${sonarrWebhook.triggers.onUpgrade ? 'active' : 'inactive'}`}>
-                      {sonarrWebhook.triggers.onUpgrade ? '✓' : '✗'}
-                    </span>
-                  </div>
-                </div>
-              )}
-              {sonarrWebhook.stats && (
-                <div className="webhook-stats">
-                  <div className="webhook-stats-title">Statistics</div>
-                  <div className="webhook-stats-grid">
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Events Received</span>
-                      <span className="webhook-stat-value">{sonarrWebhook.stats.eventsReceived ?? 0}</span>
-                    </div>
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Polls Skipped</span>
-                      <span className="webhook-stat-value">{sonarrWebhook.stats.pollsSkipped ?? 0}</span>
-                    </div>
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Last Event</span>
-                      <span className="webhook-stat-value">{formatTimeAgo(sonarrWebhook.stats.lastWebhookTimestamp)}</span>
-                    </div>
-                  </div>
-                </div>
-              )}
-            </div>
-            <div className="webhook-instance">
-              <h3>Radarr</h3>
-              <div className="webhook-status">
-                <span className={`status-indicator ${radarrWebhook.enabled ? 'enabled' : 'disabled'}`}>
-                  {radarrWebhook.enabled ? '● Enabled' : '○ Disabled'}
-                </span>
-                {!radarrWebhook.enabled && (
-                  <button onClick={enableRadarrWebhook} className="enable-webhook-btn" disabled={webhookLoading}>
-                    Enable Sofarr Webhooks
-                  </button>
-                )}
-                {radarrWebhook.enabled && (
-                  <button onClick={testRadarrWebhook} className="test-webhook-btn" disabled={webhookLoading}>
-                    Test
-                  </button>
-                )}
-              </div>
-              {radarrWebhook.enabled && (
-                <div className="webhook-triggers">
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Grab</span>
-                    <span className={`trigger-value ${radarrWebhook.triggers.onGrab ? 'active' : 'inactive'}`}>
-                      {radarrWebhook.triggers.onGrab ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Download</span>
-                    <span className={`trigger-value ${radarrWebhook.triggers.onDownload ? 'active' : 'inactive'}`}>
-                      {radarrWebhook.triggers.onDownload ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Import</span>
-                    <span className={`trigger-value ${radarrWebhook.triggers.onImport ? 'active' : 'inactive'}`}>
-                      {radarrWebhook.triggers.onImport ? '✓' : '✗'}
-                    </span>
-                  </div>
-                  <div className="trigger-item">
-                    <span className="trigger-label">On Upgrade</span>
-                    <span className={`trigger-value ${radarrWebhook.triggers.onUpgrade ? 'active' : 'inactive'}`}>
-                      {radarrWebhook.triggers.onUpgrade ? '✓' : '✗'}
-                    </span>
-                  </div>
-                </div>
-              )}
-              {radarrWebhook.stats && (
-                <div className="webhook-stats">
-                  <div className="webhook-stats-title">Statistics</div>
-                  <div className="webhook-stats-grid">
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Events Received</span>
-                      <span className="webhook-stat-value">{radarrWebhook.stats.eventsReceived ?? 0}</span>
-                    </div>
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Polls Skipped</span>
-                      <span className="webhook-stat-value">{radarrWebhook.stats.pollsSkipped ?? 0}</span>
-                    </div>
-                    <div className="webhook-stat">
-                      <span className="webhook-stat-label">Last Event</span>
-                      <span className="webhook-stat-value">{formatTimeAgo(radarrWebhook.stats.lastWebhookTimestamp)}</span>
-                    </div>
-                  </div>
-                </div>
-              )}
-            </div>
-          </div>
-        )}
-      </div>
-
-      <footer className="app-footer">
-        <p>Ensure your media is tagged with "user:username" in Sonarr/Radarr to match downloads to users.</p>
-      </footer>
-    </div>
-  );
-}
-
-export default App;

client/src/api.js

@@ -0,0 +1,353 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from './state.js';
+
+export async function checkAuthentication() {
+  try {
+    // Fetch both auth state and a fresh CSRF token in parallel
+    const [meRes, csrfRes] = await Promise.all([
+      fetch('/api/auth/me'),
+      fetch('/api/auth/csrf')
+    ]);
+    const data = await meRes.json();
+    const csrfData = await csrfRes.json();
+    if (csrfData.csrfToken) state.csrfToken = csrfData.csrfToken;
+
+    if (data.authenticated) {
+      state.currentUser = data.user;
+      state.isAdmin = !!data.user.isAdmin;
+      return { authenticated: true, user: data.user };
+    } else {
+      return { authenticated: false };
+    }
+  } catch (err) {
+    console.error('Authentication check failed:', err);
+    return { authenticated: false };
+  }
+}
+
+export async function handleLogin(username, password, rememberMe) {
+  try {
+    const response = await fetch('/api/auth/login', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({ username, password, rememberMe })
+    });
+    
+    const data = await response.json();
+    
+    if (data.success) {
+      state.currentUser = data.user;
+      state.isAdmin = !!data.user.isAdmin;
+      // Store CSRF token returned by login for use in subsequent requests
+      if (data.csrfToken) state.csrfToken = data.csrfToken;
+      return { success: true, user: data.user };
+    } else {
+      return { success: false, error: data.error || 'Login failed' };
+    }
+  } catch (err) {
+    console.error(err);
+    return { success: false, error: 'Login failed. Please try again.' };
+  }
+}
+
+export async function handleLogout() {
+  try {
+    await fetch('/api/auth/logout', {
+      method: 'POST',
+      headers: state.csrfToken ? { 'X-CSRF-Token': state.csrfToken } : {}
+    });
+    state.currentUser = null;
+    state.csrfToken = null;
+    return { success: true };
+  } catch (err) {
+    console.error('Logout failed:', err);
+    return { success: false };
+  }
+}
+
+export async function loadHistory(forceRefresh = false) {
+  try {
+    const params = new URLSearchParams({ days: state.historyDays });
+    if (state.showAll) params.set('showAll', 'true');
+    if (forceRefresh) params.set('_t', Date.now());
+    const res = await fetch(`/api/history/recent?${params}`);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    return { success: true, history: data.history || [] };
+  } catch (err) {
+    console.error('[History] Load error:', err);
+    return { success: false, error: 'Failed to load history.' };
+  }
+}
+
+export async function handleBlocklistSearch(download) {
+  try {
+    const res = await fetch('/api/dashboard/blocklist-search', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CSRF-Token': state.csrfToken
+      },
+      body: JSON.stringify({
+        arrQueueId: download.arrQueueId,
+        arrType: download.arrType,
+        arrInstanceUrl: download.arrInstanceUrl,
+        arrInstanceKey: download.arrInstanceKey,
+        arrContentId: download.arrContentId,
+        arrContentIds: download.arrContentIds,
+        arrSeriesId: download.arrSeriesId,
+        arrContentType: download.arrContentType
+      })
+    });
+
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      throw new Error(data.error || `HTTP ${res.status}`);
+    }
+
+    return { success: true };
+  } catch (err) {
+    console.error('[Blocklist] Error:', err);
+    throw err;
+  }
+}
+
+export async function loadAppVersion() {
+  try {
+    const res = await fetch('/health');
+    const data = await res.json();
+    return data.version || null;
+  } catch (err) {
+    return null;
+  }
+}
+
+export async function fetchWebhookMetrics() {
+  try {
+    const res = await fetch('/api/dashboard/webhook-metrics');
+    if (!res.ok) return null;
+    return await res.json();
+  } catch (err) {
+    return null;
+  }
+}
+
+export async function fetchWebhookStatus() {
+  try {
+    // Fetch metrics in parallel
+    const metricsPromise = fetchWebhookMetrics();
+
+    // Fetch webhook configuration status (checks SOFARR_BASE_URL and SOFARR_WEBHOOK_SECRET)
+    let webhookConfigValid = false;
+    try {
+      const configRes = await fetch('/api/webhook/config');
+      if (configRes.ok) {
+        const configData = await configRes.json();
+        webhookConfigValid = configData.valid || false;
+      }
+    } catch (err) {
+      // Config endpoint not available, assume invalid
+    }
+
+    // Fetch Sonarr notifications
+    let sonarrEnabled = false;
+    let sonarrTriggers = { onGrab: false, onDownload: false, onImport: false, onUpgrade: false };
+    try {
+      const sonarrRes = await fetch('/api/sonarr/notifications');
+      if (sonarrRes.ok) {
+        const sonarrData = await sonarrRes.json();
+        const sonarrSofarr = sonarrData.find(n => n.name === 'Sofarr');
+        sonarrEnabled = webhookConfigValid && !!sonarrSofarr;
+        if (sonarrSofarr) {
+          sonarrTriggers = {
+            onGrab: sonarrSofarr.onGrab,
+            onDownload: sonarrSofarr.onDownload,
+            onImport: sonarrSofarr.onImport,
+            onUpgrade: sonarrSofarr.onUpgrade
+          };
+        }
+      }
+    } catch (err) {
+      // Sonarr not configured
+    }
+
+    // Fetch Radarr notifications
+    let radarrEnabled = false;
+    let radarrTriggers = { onGrab: false, onDownload: false, onImport: false, onUpgrade: false };
+    try {
+      const radarrRes = await fetch('/api/radarr/notifications');
+      if (radarrRes.ok) {
+        const radarrData = await radarrRes.json();
+        const radarrSofarr = radarrData.find(n => n.name === 'Sofarr');
+        radarrEnabled = webhookConfigValid && !!radarrSofarr;
+        if (radarrSofarr) {
+          radarrTriggers = {
+            onGrab: radarrSofarr.onGrab,
+            onDownload: radarrSofarr.onDownload,
+            onImport: radarrSofarr.onImport,
+            onUpgrade: radarrSofarr.onUpgrade
+          };
+        }
+      }
+    } catch (err) {
+      // Radarr not configured
+    }
+
+    // Fetch Ombi webhook status
+    let ombiEnabled = false;
+    let ombiTriggers = { requestAvailable: false, requestApproved: false, requestDeclined: false, requestPending: false, requestProcessing: false };
+    let ombiStats = null;
+    try {
+      const ombiRes = await fetch('/api/ombi/webhook/status');
+      if (ombiRes.ok) {
+        const ombiData = await ombiRes.json();
+        ombiEnabled = ombiData.enabled || false;
+        ombiTriggers = ombiData.triggers || { requestAvailable: false, requestApproved: false, requestDeclined: false, requestPending: false, requestProcessing: false };
+        ombiStats = ombiData.stats || null;
+      }
+    } catch (err) {
+      // Ombi not configured
+    }
+    
+    state.webhookMetrics = await metricsPromise;
+    
+    // Find instance stats
+    const instanceEntries = state.webhookMetrics ? Object.entries(state.webhookMetrics.instances || {}) : [];
+    const sonarrStats = instanceEntries.find(([url]) => url.includes('sonarr'))?.[1] || null;
+    const radarrStats = instanceEntries.find(([url]) => url.includes('radarr'))?.[1] || null;
+    
+    state.sonarrWebhook = { enabled: sonarrEnabled, triggers: sonarrTriggers, stats: sonarrStats };
+    state.radarrWebhook = { enabled: radarrEnabled, triggers: radarrTriggers, stats: radarrStats };
+    state.ombiWebhook = { enabled: ombiEnabled, triggers: ombiTriggers, stats: ombiStats };
+    
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to fetch webhook status:', err);
+    return { success: false };
+  }
+}
+
+export async function enableSonarrWebhook() {
+  try {
+    const res = await fetch('/api/sonarr/notifications/sofarr-webhook', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': state.csrfToken || '' }
+    });
+    if (!res.ok) throw new Error('Failed to enable');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to enable Sonarr webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function enableRadarrWebhook() {
+  try {
+    const res = await fetch('/api/radarr/notifications/sofarr-webhook', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': state.csrfToken || '' }
+    });
+    if (!res.ok) throw new Error('Failed to enable');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to enable Radarr webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function testSonarrWebhook() {
+  try {
+    const sonarrRes = await fetch('/api/sonarr/notifications');
+    if (!sonarrRes.ok) throw new Error('Failed to fetch notifications');
+    const sonarrData = await sonarrRes.json();
+    const sonarrSofarr = sonarrData.find(n => n.name === 'Sofarr');
+    if (!sonarrSofarr) throw new Error('Sofarr webhook not found');
+    
+    const res = await fetch('/api/sonarr/notifications/test', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CSRF-Token': state.csrfToken || ''
+      },
+      body: JSON.stringify(sonarrSofarr)
+    });
+    if (!res.ok) throw new Error('Test failed');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to test Sonarr webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function testRadarrWebhook() {
+  try {
+    const radarrRes = await fetch('/api/radarr/notifications');
+    if (!radarrRes.ok) throw new Error('Failed to fetch notifications');
+    const radarrData = await radarrRes.json();
+    const radarrSofarr = radarrData.find(n => n.name === 'Sofarr');
+    if (!radarrSofarr) throw new Error('Sofarr webhook not found');
+    
+    const res = await fetch('/api/radarr/notifications/test', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CSRF-Token': state.csrfToken || ''
+      },
+      body: JSON.stringify(radarrSofarr)
+    });
+    if (!res.ok) throw new Error('Test failed');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to test Radarr webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function enableOmbiWebhook() {
+  try {
+    const res = await fetch('/api/ombi/webhook/enable', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': state.csrfToken || '' }
+    });
+    if (!res.ok) throw new Error('Failed to enable');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to enable Ombi webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function testOmbiWebhook() {
+  try {
+    const res = await fetch('/api/ombi/webhook/test', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': state.csrfToken || '' }
+    });
+    if (!res.ok) throw new Error('Test failed');
+    await fetchWebhookStatus();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to test Ombi webhook:', err);
+    return { success: false, error: err.message };
+  }
+}
+
+export async function refreshStatusPanel() {
+  try {
+    const res = await fetch('/api/status');
+    if (!res.ok) throw new Error('Failed to fetch status: ' + res.status);
+    const data = await res.json();
+    return { success: true, data };
+  } catch (err) {
+    console.error('[Status] Error fetching status:', err);
+    return { success: false, error: err.message };
+  }
+}

client/src/main.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+// Bootstrap - wire all event handlers on DOMContentLoaded
+import { checkAuthenticationAndInit, handleLogin, handleLogoutClick } from './ui/auth.js';
+import { initDownloadClientFilter } from './ui/filters.js';
+import { initRequestFilters } from './ui/requestFilters.js';
+import { initHistoryControls } from './ui/history.js';
+import { toggleStatusPanel } from './ui/statusPanel.js';
+import { initWebhooks } from './ui/webhooks.js';
+import { initThemeSwitcher } from './ui/theme.js';
+import { initTabs, goHome } from './ui/tabs.js';
+import { handleShowAllToggle } from './sse.js';
+import { loadAppVersion } from './api.js';
+import { initClientLogCapture } from './utils/clientLogCapture.js';
+
+document.addEventListener('DOMContentLoaded', () => {
+  // Initialize client console log capturing early
+  initClientLogCapture();
+
+  // Login form
+  const loginForm = document.getElementById('login-form');
+  if (loginForm) {
+    loginForm.addEventListener('submit', handleLogin);
+  }
+  
+  // Logout button
+  const logoutBtn = document.getElementById('logout-btn');
+  if (logoutBtn) {
+    logoutBtn.addEventListener('click', handleLogoutClick);
+  }
+  
+  // Show all toggle
+  const showAllToggle = document.getElementById('show-all-toggle');
+  if (showAllToggle) {
+    showAllToggle.addEventListener('change', (e) => handleShowAllToggle(e.target.checked));
+  }
+  
+  // Status panel toggle
+  const statusToggle = document.getElementById('status-btn');
+  if (statusToggle) {
+    statusToggle.addEventListener('click', toggleStatusPanel);
+  }
+  
+  // Home button
+  const homeBtn = document.getElementById('home-btn');
+  if (homeBtn) {
+    homeBtn.addEventListener('click', goHome);
+  }
+  
+  // Initialize UI components
+  initThemeSwitcher();
+  initTabs();
+  initDownloadClientFilter();
+  initRequestFilters();
+  initHistoryControls();
+  initWebhooks();
+  
+  // Load app version
+  loadAppVersion().then(version => {
+    const versionEl = document.getElementById('app-version');
+    if (versionEl && version) {
+      versionEl.textContent = 'v' + version;
+    }
+  });
+  
+  // Check authentication and initialize
+  checkAuthenticationAndInit();
+});

client/src/main.jsx

@@ -1,11 +0,0 @@
-// Copyright (c) 2026 Gordon Bolton. MIT License.
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import App from './App.jsx'
-import './App.css'
-
-ReactDOM.createRoot(document.getElementById('root')).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-)

client/src/sse.js

@@ -0,0 +1,84 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state, SSE_RECONNECT_MS } from './state.js';
+import { renderDownloads } from './ui/downloads.js';
+import { hideError, hideLoading } from './ui/auth.js';
+import { loadHistory } from './ui/history.js';
+
+export function startSSE() {
+  stopSSE();
+  const params = state.showAll ? '?showAll=true' : '';
+  const source = new EventSource('/api/dashboard/stream' + params);
+  state.sseSource = source;
+
+  let firstMessage = true;
+  source.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      state.currentUser = data.user;
+      state.isAdmin = !!data.isAdmin;
+      state.downloads = data.downloads;
+      // Store download clients and update filter dropdown
+      if (data.downloadClients) {
+        state.downloadClients = data.downloadClients;
+        // Trigger filter update
+        const filterUpdateEvent = new CustomEvent('downloadClientsUpdated');
+        document.dispatchEvent(filterUpdateEvent);
+      }
+      // Store Ombi requests and base URL
+      if (data.ombiRequests) {
+        state.ombiRequests = data.ombiRequests;
+        // Trigger requests update event
+        const requestsUpdateEvent = new CustomEvent('ombiRequestsUpdated');
+        document.dispatchEvent(requestsUpdateEvent);
+      }
+      if (data.ombiBaseUrl) {
+        state.ombiBaseUrl = data.ombiBaseUrl;
+      }
+      document.getElementById('currentUser').textContent = state.currentUser || '-';
+      renderDownloads();
+      hideError();
+      if (firstMessage) { firstMessage = false; hideLoading(); }
+    } catch (err) {
+      console.error('[SSE] Failed to parse message:', err);
+    }
+  };
+
+  // Listen for history-update events from server
+  source.addEventListener('history-update', (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      console.log('[SSE] History update received:', data.type);
+      // Trigger history reload
+      const historyReloadEvent = new CustomEvent('historyReload');
+      document.dispatchEvent(historyReloadEvent);
+    } catch (err) {
+      console.error('[SSE] Failed to parse history-update message:', err);
+    }
+  });
+
+  source.onerror = () => {
+    // EventSource retries automatically; we just log and show a reconnecting indicator
+    console.warn('[SSE] Connection lost, browser will retry...');
+  };
+
+  console.log('[SSE] Stream connected');
+}
+
+export function stopSSE() {
+  if (state.sseReconnectTimer) { clearTimeout(state.sseReconnectTimer); state.sseReconnectTimer = null; }
+  if (state.sseSource) {
+    state.sseSource.close();
+    state.sseSource = null;
+    console.log('[SSE] Stream closed');
+  }
+}
+
+export function handleShowAllToggle(checked) {
+  state.showAll = checked;
+  // Re-open stream with updated showAll param
+  startSSE();
+  // Trigger history reload with updated showAll param
+  const historyReloadEvent = new CustomEvent('historyReload');
+  document.dispatchEvent(historyReloadEvent);
+}

client/src/state.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+// Global state (using objects for mutability across modules)
+export const state = {
+  currentUser: null,
+  downloads: [],
+  downloadClients: [], // List of download clients from server (for ordering/filtering)
+  selectedDownloadClients: [], // Array of selected client IDs for multi-select filter
+  isAdmin: false,
+  showAll: false,
+  csrfToken: null, // double-submit CSRF token, sent as X-CSRF-Token on mutating requests
+  ombiBaseUrl: null, // Ombi base URL for generating links
+  ombiRequests: null, // Ombi requests data
+  
+  // History section state
+  historyDays: 7, // Default value, will be loaded from localStorage
+  historyRefreshHandle: null,
+  ignoreAvailable: false, // Default value, will be loaded from localStorage
+  lastHistoryItems: [], // raw items from last fetch, for re-filtering without a network round-trip
+  
+  // SSE stream state
+  sseSource: null,
+  sseReconnectTimer: null,
+  
+  // Status panel state
+  statusRefreshHandle: null,
+  
+  // Webhooks state
+  webhookSectionExpanded: false,
+  webhookLoading: false,
+  sonarrWebhook: { enabled: false, triggers: { onGrab: false, onDownload: false, onImport: false, onUpgrade: false }, stats: null },
+  radarrWebhook: { enabled: false, triggers: { onGrab: false, onDownload: false, onImport: false, onUpgrade: false }, stats: null },
+  ombiWebhook: { enabled: false, triggers: { requestAvailable: false, requestApproved: false, requestDeclined: false, requestPending: false, requestProcessing: false }, stats: null },
+  webhookMetrics: null,
+
+  // Request filter state
+  selectedRequestTypes: ['movie', 'tv'],
+  selectedRequestStatuses: [],
+  requestSortMode: 'requestedDate_desc',
+  requestSearchQuery: ''
+};
+
+// Constants
+export const SPLASH_MIN_MS = 1200; // minimum splash display time
+export const HISTORY_REFRESH_MS = 5 * 60 * 1000; // auto-refresh history every 5 min
+export const SSE_RECONNECT_MS = 3000; // browser already retries, but we add explicit backoff too
+export const STATUS_REFRESH_MS = 5000;

client/src/ui/auth.js

@@ -0,0 +1,176 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state, SPLASH_MIN_MS } from '../state.js';
+import { checkAuthentication, handleLogin as apiHandleLogin, handleLogout as apiHandleLogout } from '../api.js';
+import { startSSE, stopSSE } from '../sse.js';
+import { stopHistoryRefresh, clearHistory, startHistoryRefresh } from './history.js';
+import { closeStatusPanel } from './statusPanel.js';
+
+export function fadeOutLogin() {
+  return new Promise(resolve => {
+    const login = document.getElementById('login-container');
+    login.classList.add('fade-out');
+    login.addEventListener('transitionend', () => {
+      login.classList.add('hidden');
+      login.classList.remove('fade-out');
+      resolve();
+    }, { once: true });
+  });
+}
+
+export function showSplash() {
+  const splash = document.getElementById('splash-screen');
+  splash.classList.remove('hidden');
+  splash.style.opacity = '1';
+  splash.classList.remove('fade-out');
+}
+
+export function dismissSplash(startTime) {
+  return new Promise(resolve => {
+    const elapsed = Date.now() - (startTime || 0);
+    const remaining = Math.max(0, SPLASH_MIN_MS - elapsed);
+    setTimeout(() => {
+      const splash = document.getElementById('splash-screen');
+      splash.classList.add('fade-out');
+      // Fallback: resolve after transition duration + buffer in case
+      // transitionend never fires (e.g. display was toggled in same frame)
+      const TRANSITION_MS = 400;
+      const fallback = setTimeout(() => {
+        splash.classList.add('hidden');
+        resolve();
+      }, TRANSITION_MS + 100);
+      splash.addEventListener('transitionend', () => {
+        clearTimeout(fallback);
+        splash.classList.add('hidden');
+        resolve();
+      }, { once: true });
+    }, remaining);
+  });
+}
+
+export async function checkAuthenticationAndInit() {
+  const splashStart = Date.now();
+  try {
+    const result = await checkAuthentication();
+    if (result.authenticated) {
+      showDashboard();
+      showLoading();
+      startSSE();
+      await dismissSplash(splashStart);
+    } else {
+      await dismissSplash(splashStart);
+      showLogin();
+    }
+  } catch (err) {
+    console.error('Authentication check failed:', err);
+    await dismissSplash(splashStart);
+    showLogin();
+  }
+}
+
+export async function handleLogin(e) {
+  e.preventDefault();
+  
+  const username = document.getElementById('username').value;
+  const password = document.getElementById('password').value;
+  const rememberMe = document.getElementById('remember-me').checked;
+  
+  try {
+    const result = await apiHandleLogin(username, password, rememberMe);
+    
+    if (result.success) {
+      // Fade out login, then show splash while opening SSE stream.
+      // requestAnimationFrame ensures the browser paints the splash at
+      // opacity:1 before dismissSplash adds fade-out, so the CSS
+      // transition fires and transitionend is guaranteed.
+      await fadeOutLogin();
+      showSplash();
+      await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
+      showDashboard();
+      showLoading();
+      const splashStart = Date.now();
+      startSSE();
+      await dismissSplash(splashStart);
+    } else {
+      showLoginError(result.error || 'Login failed');
+    }
+  } catch (err) {
+    showLoginError('Login failed. Please try again.');
+    console.error(err);
+  }
+}
+
+export async function handleLogoutClick() {
+  try {
+    stopSSE();
+    stopHistoryRefresh();
+    if (state.statusRefreshHandle) { clearInterval(state.statusRefreshHandle); state.statusRefreshHandle = null; }
+    await apiHandleLogout();
+    state.currentUser = null;
+    clearHistory();
+    showLogin();
+  } catch (err) {
+    console.error('Logout failed:', err);
+  }
+}
+
+export function showLogin() {
+  document.getElementById('login-container').classList.remove('hidden');
+  document.getElementById('dashboard-container').classList.add('hidden');
+  hideLoginError();
+}
+
+export function showDashboard() {
+  document.getElementById('login-container').classList.add('hidden');
+  document.getElementById('dashboard-container').classList.remove('hidden');
+  document.getElementById('currentUser').textContent = state.currentUser.name || '-';
+  // Always start with status panel hidden (guards against stale display value on re-login)
+  const sp = document.getElementById('status-panel');
+  sp.classList.add('hidden');
+  // Also hide webhooks-section to keep them in sync (both show/hide together)
+  const webhooksSection = document.getElementById('webhooks-section');
+  if (webhooksSection) webhooksSection.classList.add('hidden');
+  const adminControls = document.getElementById('admin-controls');
+  if (state.isAdmin) {
+    adminControls.classList.remove('hidden');
+  } else {
+    adminControls.classList.add('hidden');
+  }
+  // Note: webhooks-section visibility is controlled by toggleStatusPanel()
+  // Initialise days input from saved value
+  const daysInput = document.getElementById('history-days');
+  if (daysInput) daysInput.value = state.historyDays;
+  startHistoryRefresh();
+}
+
+export function showLoginError(message) {
+  const errorDiv = document.getElementById('login-error');
+  errorDiv.textContent = message;
+  errorDiv.classList.remove('hidden');
+}
+
+export function hideLoginError() {
+  const errorDiv = document.getElementById('login-error');
+  errorDiv.classList.add('hidden');
+}
+
+export function showError(message) {
+  const errorDiv = document.getElementById('error-message');
+  errorDiv.textContent = message;
+  errorDiv.classList.remove('hidden');
+}
+
+export function hideError() {
+  const errorDiv = document.getElementById('error-message');
+  errorDiv.classList.add('hidden');
+}
+
+export function showLoading() {
+  const loading = document.getElementById('loading');
+  loading.classList.remove('hidden');
+}
+
+export function hideLoading() {
+  const loading = document.getElementById('loading');
+  loading.classList.add('hidden');
+}

client/src/ui/downloads.js

@@ -0,0 +1,572 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+import { formatSize, formatSpeed, formatEpisodeInfo, escapeHtml } from '../utils/format.js';
+import { handleBlocklistSearch } from '../api.js';
+
+export function renderTagBadges(tagBadges, showAll, matchedUserTag) {
+  const fragment = document.createDocumentFragment();
+
+  if (showAll && tagBadges && tagBadges.length > 0) {
+    const unmatched = tagBadges.filter(b => !b.matchedUser);
+    const matched = tagBadges.filter(b => b.matchedUser);
+    for (const b of unmatched) {
+      const badge = document.createElement('span');
+      badge.className = 'download-user-badge unmatched';
+      badge.textContent = b.label;
+      fragment.appendChild(badge);
+    }
+    for (const b of matched) {
+      const badge = document.createElement('span');
+      badge.className = 'download-user-badge';
+      badge.textContent = b.matchedUser;
+      fragment.appendChild(badge);
+    }
+  } else if (matchedUserTag) {
+    const matchedBadge = document.createElement('span');
+    matchedBadge.className = 'download-user-badge';
+    matchedBadge.textContent = matchedUserTag;
+    fragment.appendChild(matchedBadge);
+  }
+
+  return fragment;
+}
+
+function createClientLogo(download) {
+  const clientLogoWrapper = document.createElement('span');
+  clientLogoWrapper.className = 'download-client-logo-wrapper download-card-logo-wrapper';
+  if (download.isOrphaned) {
+    clientLogoWrapper.classList.add('orphaned-logo');
+  }
+
+  const clientLogo = document.createElement('img');
+  clientLogo.className = 'download-client-logo';
+  clientLogo.src = `/images/clients/${download.client}.svg`;
+  clientLogo.alt = `${download.instanceName || download.client} icon`;
+  clientLogo.title = download.isOrphaned
+    ? "This download is managed by a *arr instance's download client that is not configured in Sofarr."
+    : (download.instanceName || download.client);
+  clientLogo.onerror = () => {
+    clientLogoWrapper.textContent = download.client.charAt(0).toUpperCase();
+    clientLogoWrapper.classList.add('fallback');
+  };
+
+  clientLogoWrapper.appendChild(clientLogo);
+  return clientLogoWrapper;
+}
+
+function createServiceIcons(download) {
+  const container = document.createElement('span');
+  container.className = 'service-icons-container';
+
+  // Add Ombi icon for all users if ombiLink exists
+  if (download.ombiLink) {
+    const ombiIcon = document.createElement('img');
+    ombiIcon.className = 'service-icon ombi';
+    ombiIcon.src = '/images/ombi.svg';
+    ombiIcon.alt = 'Ombi';
+    ombiIcon.title = download.ombiTooltip || 'Ombi';
+    ombiIcon.href = download.ombiLink;
+    const ombiLink = document.createElement('a');
+    ombiLink.href = download.ombiLink;
+    ombiLink.target = '_blank';
+    ombiLink.appendChild(ombiIcon);
+    container.appendChild(ombiLink);
+  }
+
+  // Add Sonarr/Radarr icon for admin users if arrLink exists
+  if (state.isAdmin && download.arrLink) {
+    const arrIcon = document.createElement('img');
+    if (download.arrType === 'sonarr') {
+      arrIcon.className = 'service-icon sonarr';
+      arrIcon.src = '/images/sonarr.svg';
+      arrIcon.alt = 'Sonarr';
+    } else if (download.arrType === 'radarr') {
+      arrIcon.className = 'service-icon radarr';
+      arrIcon.src = '/images/radarr.svg';
+      arrIcon.alt = 'Radarr';
+    }
+    arrIcon.title = download.arrType === 'sonarr' ? 'Sonarr' : 'Radarr';
+    const arrLink = document.createElement('a');
+    arrLink.href = download.arrLink;
+    arrLink.target = '_blank';
+    arrLink.appendChild(arrIcon);
+    container.appendChild(arrLink);
+  }
+
+  return container;
+}
+
+export function renderDownloads() {
+  const downloadsList = document.getElementById('downloads-list');
+  const noDownloads = document.getElementById('no-downloads');
+
+  // Filter downloads by selected clients
+  let filteredDownloads = state.downloads;
+  if (state.selectedDownloadClients.length > 0) {
+    // Map indices to client objects, then filter by both client type and instanceId
+    const selectedClients = state.selectedDownloadClients.map(idx => state.downloadClients[idx]).filter(Boolean);
+    filteredDownloads = state.downloads.filter(d =>
+      selectedClients.some(c => c.type === d.client && c.id === d.instanceId)
+    );
+  }
+
+  // Sort downloads by client order (matching the order in downloadClients)
+  if (state.downloadClients.length > 0) {
+    const clientOrder = new Map(state.downloadClients.map((c, idx) => [c.id, idx]));
+    filteredDownloads = [...filteredDownloads].sort((a, b) => {
+      const orderA = clientOrder.get(a.instanceId) ?? Infinity;
+      const orderB = clientOrder.get(b.instanceId) ?? Infinity;
+      return orderA - orderB;
+    });
+  }
+
+  if (filteredDownloads.length === 0) {
+    noDownloads.classList.remove('hidden');
+    downloadsList.innerHTML = '';
+    return;
+  }
+
+  noDownloads.classList.add('hidden');
+
+  // Get existing cards
+  const existingCards = new Map();
+  downloadsList.querySelectorAll('.download-card').forEach(card => {
+    existingCards.set(card.dataset.id, card);
+  });
+
+  // Track which downloads we've processed
+  const processedIds = new Set();
+
+  filteredDownloads.forEach(download => {
+    const id = download.title;
+    processedIds.add(id);
+
+    const existingCard = existingCards.get(id);
+    if (existingCard) {
+      // Update existing card
+      updateDownloadCard(existingCard, download);
+    } else {
+      // Create new card
+      const card = createDownloadCard(download);
+      downloadsList.appendChild(card);
+    }
+  });
+
+  // Remove cards for downloads that no longer exist
+  existingCards.forEach((card, id) => {
+    if (!processedIds.has(id)) {
+      card.remove();
+    }
+  });
+}
+
+export function updateDownloadCard(card, download) {
+  // Remove old header-right container if it exists
+  const oldRightSide = card.querySelector('.download-header-right');
+  if (oldRightSide) {
+    oldRightSide.remove();
+  }
+
+  // Remove old user badges directly in header
+  const oldBadges = card.querySelectorAll('.download-header .download-user-badge');
+  oldBadges.forEach(badge => badge.remove());
+
+  // Remove old client logo from header (old structure)
+  const oldLogoInHeader = card.querySelector('.download-header .download-client-logo-wrapper');
+  if (oldLogoInHeader) {
+    oldLogoInHeader.remove();
+  }
+
+  // Remove old client logo from card (new structure) if it exists
+  const oldLogoInCard = card.querySelector('.download-card-logo-wrapper');
+  if (oldLogoInCard) {
+    oldLogoInCard.remove();
+  }
+
+  // Add new right-side container with user badge only
+  const header = card.querySelector('.download-header');
+  if (header && !header.querySelector('.download-header-right')) {
+    const rightSide = document.createElement('div');
+    rightSide.className = 'download-header-right';
+
+    const badges = renderTagBadges(download.tagBadges, state.showAll, download.matchedUserTag);
+    rightSide.appendChild(badges);
+
+    header.appendChild(rightSide);
+  }
+
+  // Add client logo to card (positioned at bottom right via CSS)
+  if (download.client && !card.querySelector('.download-card-logo-wrapper')) {
+    card.appendChild(createClientLogo(download));
+  }
+
+  // Update status
+  const statusEl = card.querySelector('.download-status');
+  if (statusEl && statusEl.textContent !== download.status) {
+    statusEl.textContent = download.status;
+    statusEl.className = `download-status ${download.status}`;
+  }
+  
+  // Update progress bar and missing pieces
+  const progressContainer = card.querySelector('.progress-container');
+  if (progressContainer && download.progress !== undefined) {
+    const progressBar = progressContainer.querySelector('.progress-bar');
+    const progressText = progressContainer.querySelector('.progress-text');
+    const missingText = progressContainer.querySelector('.missing-text');
+    
+    if (progressBar) {
+      const downloaded = progressBar.querySelector('.downloaded');
+      if (downloaded) {
+        downloaded.style.width = download.progress + '%';
+      }
+    }
+    
+    if (progressText) {
+      progressText.textContent = download.progress + '%';
+    }
+    
+    if (missingText) {
+      const totalMb = parseFloat(download.mb) || parseFloat(download.size);
+      const missingMb = parseFloat(download.mbmissing) || 0;
+      if (missingMb > 0 && totalMb > 0) {
+        missingText.textContent = `(missing ${missingMb.toFixed(1)} of ${totalMb.toFixed(1)} MB)`;
+      } else {
+        missingText.textContent = '';
+      }
+    }
+  }
+  
+  // Update speed
+  const speedEl = card.querySelector('.detail-item[data-label="Speed"] .detail-value');
+  if (speedEl && download.speed !== undefined) {
+    speedEl.textContent = formatSpeed(download.speed);
+  }
+  
+  // Update ETA
+  const etaEl = card.querySelector('.detail-item[data-label="ETA"] .detail-value');
+  if (etaEl && download.eta !== undefined) {
+    etaEl.textContent = download.eta;
+  }
+  
+  // Update qBittorrent-specific fields
+  if (download.qbittorrent) {
+    const seedsEl = card.querySelector('.detail-item[data-label="Seeds"] .detail-value');
+    if (seedsEl && download.seeds !== undefined) {
+      seedsEl.textContent = download.seeds;
+    }
+    
+    const peersEl = card.querySelector('.detail-item[data-label="Peers"] .detail-value');
+    if (peersEl && download.peers !== undefined) {
+      peersEl.textContent = download.peers;
+    }
+    
+    const availabilityItem = card.querySelector('.detail-item[data-label="Availability"]');
+    if (availabilityItem && download.availability !== undefined) {
+      availabilityItem.querySelector('.detail-value').textContent = `${download.availability}%`;
+      availabilityItem.classList.toggle('availability-warning', parseFloat(download.availability) < 100);
+    }
+  }
+}
+
+export async function handleBlocklistSearchClick(btn, download) {
+  console.log('[Blocklist] Clicked, download:', download);
+  console.log('[Blocklist] Required fields:', {
+    arrQueueId: download.arrQueueId,
+    arrType: download.arrType,
+    arrInstanceUrl: download.arrInstanceUrl,
+    arrInstanceKey: download.arrInstanceKey,
+    arrContentId: download.arrContentId,
+    arrContentIds: download.arrContentIds,
+    arrSeriesId: download.arrSeriesId,
+    arrContentType: download.arrContentType,
+    isAdmin: state.isAdmin,
+    canBlocklist: download.canBlocklist
+  });
+
+  if (!confirm(`Blocklist "${download.title}" and trigger a new search?\n\nThis will:\n• Remove the download from the download client\n• Add this release to the blocklist\n• Trigger an automatic search for a new release`)) return;
+
+  btn.disabled = true;
+  btn.textContent = '⏳ Working…';
+
+  try {
+    await handleBlocklistSearch(download);
+    btn.textContent = '✓ Done — searching…';
+    btn.className = 'blocklist-search-btn success';
+  } catch (err) {
+    console.error('[Blocklist] Error:', err);
+    btn.disabled = false;
+    btn.textContent = '⛔ Blocklist & Search';
+    btn.className = 'blocklist-search-btn error';
+    btn.title = `Failed: ${err.message}`;
+    setTimeout(() => {
+      btn.className = 'blocklist-search-btn';
+      btn.title = 'Remove this release from the download client, add it to the blocklist, and trigger an automatic search';
+    }, 4000);
+  }
+}
+
+export function createDownloadCard(download) {
+  const card = document.createElement('div');
+  card.className = `download-card ${download.type}${download.isOrphaned ? ' orphaned' : ''}`;
+  card.dataset.id = download.title;
+  
+  // Cover art
+  if (download.coverArt) {
+    const coverDiv = document.createElement('div');
+    coverDiv.className = 'download-cover';
+    const coverImg = document.createElement('img');
+    // Proxy cover art through the server so the CSP img-src 'self' rule
+    // is satisfied (external poster URLs would be blocked otherwise).
+    coverImg.src = download.coverArt
+      ? '/api/dashboard/cover-art?url=' + encodeURIComponent(download.coverArt)
+      : '';
+    coverImg.alt = download.movieName || download.seriesName || download.title;
+    coverImg.loading = 'lazy';
+    coverDiv.appendChild(coverImg);
+    card.appendChild(coverDiv);
+  }
+  
+  // Info wrapper
+  const infoDiv = document.createElement('div');
+  infoDiv.className = 'download-info';
+  
+  const header = document.createElement('div');
+  header.className = 'download-header';
+
+  const type = document.createElement('span');
+  type.className = `download-type ${download.type}`;
+  if (download.type === 'series') {
+    type.textContent = '📺 Series';
+  } else if (download.type === 'movie') {
+    type.textContent = '🎬 Movie';
+  } else if (download.type === 'torrent') {
+    const instName = download.instanceName ? ` (${download.instanceName})` : '';
+    type.textContent = `📥 Torrent${instName}`;
+  } else {
+    type.textContent = download.type;
+  }
+
+  const status = document.createElement('span');
+  status.className = `download-status ${download.status}`;
+  status.textContent = download.status;
+
+  header.appendChild(type);
+  header.appendChild(status);
+
+  if (download.importIssues && download.importIssues.length > 0) {
+    const issueBadge = document.createElement('span');
+    issueBadge.className = 'import-issue-badge';
+    issueBadge.textContent = 'Import Pending';
+    issueBadge.setAttribute('data-tooltip', download.importIssues.join('\n'));
+    header.appendChild(issueBadge);
+  }
+
+  if ((state.isAdmin || download.canBlocklist) && download.arrQueueId) {
+    const blBtn = document.createElement('button');
+    blBtn.className = 'blocklist-search-btn';
+    blBtn.textContent = '⛔ Blocklist & Search';
+    blBtn.title = 'Remove this release from the download client, add it to the blocklist, and trigger a new automatic search';
+    blBtn.addEventListener('click', () => handleBlocklistSearchClick(blBtn, download));
+    header.appendChild(blBtn);
+  }
+
+  // Right side container for user badge only
+  const rightSide = document.createElement('div');
+  rightSide.className = 'download-header-right';
+
+  const badges = renderTagBadges(download.tagBadges, state.showAll, download.matchedUserTag);
+  rightSide.appendChild(badges);
+
+  header.appendChild(rightSide);
+
+  // Add client logo to card (positioned at bottom right via CSS)
+  if (download.client) {
+    card.appendChild(createClientLogo(download));
+  }
+
+  const title = document.createElement('h3');
+  title.className = 'download-title';
+  title.textContent = download.title;
+  
+  infoDiv.appendChild(header);
+  infoDiv.appendChild(title);
+  
+  if (download.seriesName) {
+    const series = document.createElement('p');
+    series.className = 'download-series';
+    
+    // Add service icons
+    const serviceIcons = createServiceIcons(download);
+    if (serviceIcons.hasChildNodes()) {
+      series.appendChild(serviceIcons);
+      series.appendChild(document.createTextNode(' '));
+    }
+    
+    // Series name is now plain text for all users (no link)
+    const seriesText = document.createElement('span');
+    seriesText.textContent = `Series: ${download.seriesName}`;
+    series.appendChild(seriesText);
+    
+    infoDiv.appendChild(series);
+    const epEl = formatEpisodeInfo(download.episodes);
+    if (epEl) infoDiv.appendChild(epEl);
+  }
+  
+  if (download.movieName) {
+    const movie = document.createElement('p');
+    movie.className = 'download-movie';
+    
+    // Add service icons
+    const serviceIcons = createServiceIcons(download);
+    if (serviceIcons.hasChildNodes()) {
+      movie.appendChild(serviceIcons);
+      movie.appendChild(document.createTextNode(' '));
+    }
+    
+    // Movie name is now plain text for all users (no link)
+    const movieText = document.createElement('span');
+    movieText.textContent = `Movie: ${download.movieName}`;
+    movie.appendChild(movieText);
+    
+    infoDiv.appendChild(movie);
+  }
+
+  const details = document.createElement('div');
+  details.className = 'download-details';
+  
+  const size = createDetailItem('Size', formatSize(download.size));
+  details.appendChild(size);
+  
+  if (download.progress !== undefined) {
+    const progressItem = document.createElement('div');
+    progressItem.className = 'detail-item progress-item';
+    progressItem.dataset.label = 'Progress';
+    
+    const labelSpan = document.createElement('span');
+    labelSpan.className = 'detail-label';
+    labelSpan.textContent = 'Progress';
+    
+    const valueDiv = document.createElement('div');
+    valueDiv.className = 'progress-container';
+    
+    // Progress bar with segments
+    const totalMb = parseFloat(download.mb) || parseFloat(download.size);
+    const missingMb = parseFloat(download.mbmissing) || 0;
+    const downloadedMb = totalMb - missingMb;
+    const progressPercent = parseFloat(download.progress) || 0;
+    const missingPercent = totalMb > 0 ? (missingMb / totalMb) * 100 : 0;
+    
+    const progressBar = document.createElement('div');
+    progressBar.className = 'progress-bar';
+    
+    // Downloaded portion (green)
+    if (progressPercent > 0) {
+      const downloaded = document.createElement('div');
+      downloaded.className = 'progress-segment downloaded';
+      downloaded.style.width = progressPercent + '%';
+      progressBar.appendChild(downloaded);
+    }
+    
+    valueDiv.appendChild(progressBar);
+    
+    // Text showing percentage
+    const progressText = document.createElement('span');
+    progressText.className = 'progress-text';
+    progressText.textContent = download.progress + '%';
+    valueDiv.appendChild(progressText);
+    
+    // Missing pieces text (only for torrent clients like qBittorrent)
+    if (download.client && (download.client === 'qbittorrent' || download.client === 'rtorrent') && missingMb > 0 && totalMb > 0) {
+      const missingText = document.createElement('span');
+      missingText.className = 'missing-text';
+      missingText.textContent = `(missing ${missingMb.toFixed(1)} of ${totalMb.toFixed(1)} MB)`;
+      valueDiv.appendChild(missingText);
+    }
+    
+    progressItem.appendChild(labelSpan);
+    progressItem.appendChild(valueDiv);
+    details.appendChild(progressItem);
+  }
+  
+  if (download.speed && download.speed > 0) {
+    const speed = createDetailItem('Speed', formatSpeed(download.speed));
+    details.appendChild(speed);
+  }
+  
+  if (download.eta) {
+    const eta = createDetailItem('ETA', download.eta);
+    details.appendChild(eta);
+  }
+  
+  // qBittorrent-specific fields
+  if (download.qbittorrent) {
+    if (download.seeds !== undefined) {
+      const seeds = createDetailItem('Seeds', download.seeds);
+      details.appendChild(seeds);
+    }
+    
+    if (download.peers !== undefined) {
+      const peers = createDetailItem('Peers', download.peers);
+      details.appendChild(peers);
+    }
+    
+    if (download.availability !== undefined) {
+      const availability = createDetailItem('Availability', `${download.availability}%`);
+      if (parseFloat(download.availability) < 100) availability.classList.add('availability-warning');
+      details.appendChild(availability);
+    }
+  }
+  
+  if (download.completedAt) {
+    const completed = createDetailItem('Completed', formatDate(download.completedAt));
+    details.appendChild(completed);
+  }
+
+  if (state.isAdmin && (download.downloadPath || download.targetPath)) {
+    const pathsDiv = document.createElement('div');
+    pathsDiv.className = 'download-paths';
+    if (download.downloadPath) {
+      const dlPath = document.createElement('div');
+      dlPath.className = 'path-item';
+      dlPath.innerHTML = '<span class="path-label">Download:</span> <span class="path-value">' + escapeHtml(download.downloadPath) + '</span>';
+      pathsDiv.appendChild(dlPath);
+    }
+    if (download.targetPath) {
+      const tgtPath = document.createElement('div');
+      tgtPath.className = 'path-item';
+      tgtPath.innerHTML = '<span class="path-label">Target:</span> <span class="path-value">' + escapeHtml(download.targetPath) + '</span>';
+      pathsDiv.appendChild(tgtPath);
+    }
+    details.appendChild(pathsDiv);
+  }
+  
+  infoDiv.appendChild(details);
+  card.appendChild(infoDiv);
+  
+  return card;
+}
+
+export function createDetailItem(label, value) {
+  const item = document.createElement('div');
+  item.className = 'detail-item';
+  item.dataset.label = label;
+  
+  const labelSpan = document.createElement('span');
+  labelSpan.className = 'detail-label';
+  labelSpan.textContent = label;
+  
+  const valueSpan = document.createElement('span');
+  valueSpan.className = 'detail-value';
+  valueSpan.textContent = value;
+  
+  item.appendChild(labelSpan);
+  item.appendChild(valueSpan);
+  
+  return item;
+}
+
+function formatDate(dateString) {
+  if (!dateString) return 'N/A';
+  return new Date(dateString).toLocaleString();
+}

client/src/ui/filters.js

@@ -0,0 +1,130 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+import { saveDownloadClients } from '../utils/storage.js';
+import { renderDownloads } from './downloads.js';
+
+export function initDownloadClientFilter() {
+  const filterBtn = document.getElementById('download-client-dropdown-btn');
+  const filterDropdown = document.getElementById('download-client-dropdown');
+  const selectAllBtn = document.getElementById('download-client-select-all');
+  const deselectAllBtn = document.getElementById('download-client-deselect-all');
+  
+  if (!filterBtn || !filterDropdown) return;
+  
+  filterBtn.addEventListener('click', (e) => {
+    e.stopPropagation();
+    filterDropdown.classList.toggle('open');
+  });
+  
+  if (selectAllBtn) {
+    selectAllBtn.addEventListener('click', () => toggleAllClients(true));
+  }
+  if (deselectAllBtn) {
+    deselectAllBtn.addEventListener('click', () => toggleAllClients(false));
+  }
+  
+  // Close dropdown when clicking outside
+  document.addEventListener('click', (e) => {
+    if (!filterDropdown.contains(e.target) && e.target !== filterBtn && !filterBtn.contains(e.target)) {
+      filterDropdown.classList.remove('open');
+    }
+  });
+  
+  // Listen for download clients updates from SSE
+  document.addEventListener('downloadClientsUpdated', updateDownloadClientFilter);
+  
+  // Initial filter update
+  updateDownloadClientFilter();
+}
+
+export function updateDownloadClientFilter() {
+  const filterList = document.getElementById('download-client-options');
+  if (!filterList) return;
+  
+  filterList.innerHTML = '';
+  
+  state.downloadClients.forEach((client, index) => {
+    const item = document.createElement('div');
+    item.className = 'download-client-option';
+    item.dataset.index = index;
+    
+    const checkbox = document.createElement('input');
+    checkbox.type = 'checkbox';
+    checkbox.className = 'download-client-checkbox';
+    checkbox.id = `client-${index}`;
+    checkbox.checked = state.selectedDownloadClients.includes(index);
+    checkbox.addEventListener('change', () => toggleClientSelection(index));
+    
+    const iconWrapper = document.createElement('span');
+    iconWrapper.className = 'download-client-icon';
+    const iconImg = document.createElement('img');
+    iconImg.src = `/images/clients/${client.type}.svg`;
+    iconImg.alt = `${client.name || client.type} icon`;
+    iconImg.onerror = () => {
+      iconWrapper.textContent = client.type.charAt(0).toUpperCase();
+      iconWrapper.classList.add('fallback');
+    };
+    iconWrapper.appendChild(iconImg);
+    
+    const label = document.createElement('label');
+    label.className = 'download-client-option-label';
+    label.htmlFor = `client-${index}`;
+    label.textContent = client.name || `${client.type} (${client.id})`;
+    
+    const typeBadge = document.createElement('span');
+    typeBadge.className = 'download-client-type';
+    typeBadge.textContent = client.type;
+    
+    item.appendChild(checkbox);
+    item.appendChild(iconWrapper);
+    item.appendChild(label);
+    item.appendChild(typeBadge);
+    filterList.appendChild(item);
+  });
+  
+  updateSelectedCountDisplay();
+}
+
+export function toggleClientSelection(index) {
+  const idx = state.selectedDownloadClients.indexOf(index);
+  if (idx > -1) {
+    state.selectedDownloadClients.splice(idx, 1);
+  } else {
+    state.selectedDownloadClients.push(index);
+  }
+  saveDownloadClients(state.selectedDownloadClients);
+  updateSelectedCountDisplay();
+  renderDownloads();
+}
+
+export function toggleAllClients(select) {
+  if (select) {
+    state.selectedDownloadClients = state.downloadClients.map((_, index) => index);
+  } else {
+    state.selectedDownloadClients = [];
+  }
+  saveDownloadClients(state.selectedDownloadClients);
+  updateDownloadClientFilter();
+  renderDownloads();
+}
+
+export function updateSelectedCountDisplay() {
+  const countDisplay = document.getElementById('download-client-selected-text');
+  if (!countDisplay) return;
+  
+  if (state.selectedDownloadClients.length === 0) {
+    countDisplay.textContent = 'All clients';
+  } else if (state.selectedDownloadClients.length === state.downloadClients.length) {
+    countDisplay.textContent = 'All clients';
+  } else {
+    const names = state.selectedDownloadClients
+      .map(idx => state.downloadClients[idx]?.name || state.downloadClients[idx]?.type || '')
+      .filter(Boolean);
+    if (names.length === 1) {
+      countDisplay.textContent = names[0];
+    } else {
+      countDisplay.textContent = `${state.selectedDownloadClients.length} clients`;
+    }
+  }
+}

client/src/ui/history.js

@@ -0,0 +1,283 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state, HISTORY_REFRESH_MS } from '../state.js';
+import { loadHistory as apiLoadHistory } from '../api.js';
+import { saveHistoryDays, saveIgnoreAvailable } from '../utils/storage.js';
+import { formatDate, formatEpisodeInfo, escapeHtml } from '../utils/format.js';
+import { renderTagBadges } from './downloads.js';
+
+function createServiceIcons(item) {
+  const container = document.createElement('span');
+  container.className = 'service-icons-container';
+
+  // Add Ombi icon for all users if ombiLink exists
+  if (item.ombiLink) {
+    const ombiIcon = document.createElement('img');
+    ombiIcon.className = 'service-icon ombi';
+    ombiIcon.src = '/images/ombi.svg';
+    ombiIcon.alt = 'Ombi';
+    ombiIcon.title = item.ombiTooltip || 'Ombi';
+    const ombiLink = document.createElement('a');
+    ombiLink.href = item.ombiLink;
+    ombiLink.target = '_blank';
+    ombiLink.appendChild(ombiIcon);
+    container.appendChild(ombiLink);
+  }
+
+  // Add Sonarr/Radarr icon for admin users if arrLink exists
+  if (state.isAdmin && item.arrLink) {
+    const arrIcon = document.createElement('img');
+    if (item.arrType === 'sonarr') {
+      arrIcon.className = 'service-icon sonarr';
+      arrIcon.src = '/images/sonarr.svg';
+      arrIcon.alt = 'Sonarr';
+    } else if (item.arrType === 'radarr') {
+      arrIcon.className = 'service-icon radarr';
+      arrIcon.src = '/images/radarr.svg';
+      arrIcon.alt = 'Radarr';
+    }
+    arrIcon.title = item.arrType === 'sonarr' ? 'Sonarr' : 'Radarr';
+    const arrLink = document.createElement('a');
+    arrLink.href = item.arrLink;
+    arrLink.target = '_blank';
+    arrLink.appendChild(arrIcon);
+    container.appendChild(arrLink);
+  }
+
+  return container;
+}
+
+export function initHistoryControls() {
+  const daysInput = document.getElementById('history-days');
+  const refreshBtn = document.getElementById('history-refresh-btn');
+  const ignoreToggle = document.getElementById('ignore-available-toggle');
+  if (daysInput) {
+    daysInput.addEventListener('change', () => {
+      const v = parseInt(daysInput.value, 10);
+      if (v > 0 && v <= 90) {
+        historyDays = v;
+        saveHistoryDays(v);
+        loadHistory(true);
+      }
+    });
+  }
+  if (refreshBtn) {
+    refreshBtn.addEventListener('click', () => loadHistory(true));
+  }
+  if (ignoreToggle) {
+    ignoreToggle.checked = state.ignoreAvailable;
+    ignoreToggle.addEventListener('change', () => {
+      state.ignoreAvailable = ignoreToggle.checked;
+      saveIgnoreAvailable(state.ignoreAvailable);
+      renderHistory(state.lastHistoryItems);
+    });
+  }
+
+  // Listen for history reload events from other modules
+  document.addEventListener('historyReload', () => {
+    loadHistory(true);
+  });
+}
+
+export function startHistoryRefresh() {
+  stopHistoryRefresh();
+  state.historyRefreshHandle = setInterval(() => loadHistory(), HISTORY_REFRESH_MS);
+}
+
+export function stopHistoryRefresh() {
+  if (state.historyRefreshHandle) {
+    clearInterval(state.historyRefreshHandle);
+    state.historyRefreshHandle = null;
+  }
+}
+
+export function clearHistory() {
+  state.lastHistoryItems = [];
+  document.getElementById('history-list').innerHTML = '';
+  document.getElementById('no-history').classList.add('hidden');
+  document.getElementById('history-error').classList.add('hidden');
+}
+
+export async function loadHistory(forceRefresh = false) {
+  const listEl = document.getElementById('history-list');
+  const loadingEl = document.getElementById('history-loading');
+  const errorEl = document.getElementById('history-error');
+  const noHistoryEl = document.getElementById('no-history');
+
+  loadingEl.classList.remove('hidden');
+  errorEl.classList.add('hidden');
+  noHistoryEl.classList.add('hidden');
+
+  try {
+    const result = await apiLoadHistory(forceRefresh);
+    loadingEl.classList.add('hidden');
+    if (result.success) {
+      state.lastHistoryItems = result.history;
+      renderHistory(state.lastHistoryItems);
+    } else {
+      errorEl.textContent = result.error || 'Failed to load history.';
+      errorEl.classList.remove('hidden');
+    }
+  } catch (err) {
+    loadingEl.classList.add('hidden');
+    errorEl.textContent = 'Failed to load history.';
+    errorEl.classList.remove('hidden');
+    console.error('[History] Load error:', err);
+  }
+}
+
+export function renderHistory(items) {
+  const listEl = document.getElementById('history-list');
+  const noHistoryEl = document.getElementById('no-history');
+  listEl.innerHTML = '';
+  const visible = state.ignoreAvailable
+    ? items.filter(item => !(item.outcome === 'failed' && item.availableForUpgrade))
+    : items;
+  if (!visible.length) {
+    noHistoryEl.classList.remove('hidden');
+    return;
+  }
+  noHistoryEl.classList.add('hidden');
+  visible.forEach(item => listEl.appendChild(createHistoryCard(item)));
+}
+
+export function createHistoryCard(item) {
+  const card = document.createElement('div');
+  card.className = `history-card ${item.type} ${item.outcome}`;
+
+  if (item.coverArt) {
+    const coverDiv = document.createElement('div');
+    coverDiv.className = 'history-cover';
+    const img = document.createElement('img');
+    img.src = '/api/dashboard/cover-art?url=' + encodeURIComponent(item.coverArt);
+    img.alt = item.movieName || item.seriesName || item.title;
+    img.loading = 'lazy';
+    coverDiv.appendChild(img);
+    card.appendChild(coverDiv);
+  }
+
+  const info = document.createElement('div');
+  info.className = 'history-info';
+
+  // Header row: type badge + outcome badge
+  const header = document.createElement('div');
+  header.className = 'history-card-header';
+
+  const typeBadge = document.createElement('span');
+  typeBadge.className = `history-type-badge ${item.type}`;
+  typeBadge.textContent = item.type === 'series' ? '📺 Series' : '🎬 Movie';
+  header.appendChild(typeBadge);
+
+  const outcomeBadge = document.createElement('span');
+  outcomeBadge.className = `history-outcome-badge ${item.outcome}`;
+  outcomeBadge.textContent = item.outcome === 'imported' ? '✓ Imported' : '✗ Failed';
+  header.appendChild(outcomeBadge);
+
+  if (item.availableForUpgrade) {
+    const upgradeBadge = document.createElement('span');
+    upgradeBadge.className = 'history-upgrade-badge';
+    upgradeBadge.title = 'A previous version of this item is available. An upgrade download has failed.';
+    upgradeBadge.textContent = '⬆ Available';
+    header.appendChild(upgradeBadge);
+  }
+
+  if (item.instanceName) {
+    const instBadge = document.createElement('span');
+    instBadge.className = 'history-instance-badge';
+    instBadge.textContent = item.instanceName;
+    header.appendChild(instBadge);
+  }
+
+  const badges = renderTagBadges(item.tagBadges, state.showAll, item.matchedUserTag);
+  header.appendChild(badges);
+
+  info.appendChild(header);
+
+  // Title
+  const title = document.createElement('h3');
+  title.className = 'history-title';
+  title.textContent = item.title;
+  info.appendChild(title);
+
+  // Series/movie name with service icons
+  if (item.seriesName) {
+    const p = document.createElement('p');
+    p.className = 'history-media-name';
+    
+    // Add service icons
+    const serviceIcons = createServiceIcons(item);
+    if (serviceIcons.hasChildNodes()) {
+      p.appendChild(serviceIcons);
+      p.appendChild(document.createTextNode(' '));
+    }
+    
+    // Series name is now plain text for all users (no link)
+    const seriesText = document.createElement('span');
+    seriesText.textContent = 'Series: ' + item.seriesName;
+    p.appendChild(seriesText);
+    
+    info.appendChild(p);
+    const epEl = formatEpisodeInfo(item.episodes);
+    if (epEl) info.appendChild(epEl);
+  }
+  if (item.movieName) {
+    const p = document.createElement('p');
+    p.className = 'history-media-name';
+    
+    // Add service icons
+    const serviceIcons = createServiceIcons(item);
+    if (serviceIcons.hasChildNodes()) {
+      p.appendChild(serviceIcons);
+      p.appendChild(document.createTextNode(' '));
+    }
+    
+    // Movie name is now plain text for all users (no link)
+    const movieText = document.createElement('span');
+    movieText.textContent = 'Movie: ' + item.movieName;
+    p.appendChild(movieText);
+    
+    info.appendChild(p);
+  }
+
+  // Detail pills
+  const details = document.createElement('div');
+  details.className = 'history-details';
+
+  if (item.completedAt) {
+    details.appendChild(createDetailItem('Completed', formatDate(item.completedAt)));
+  }
+  if (item.quality) {
+    details.appendChild(createDetailItem('Quality', item.quality));
+  }
+
+  // Failed imports: show failure message
+  if (item.outcome === 'failed' && item.failureMessage) {
+    const failItem = document.createElement('div');
+    failItem.className = 'history-failure-message';
+    failItem.textContent = item.failureMessage;
+    details.appendChild(failItem);
+  }
+
+  info.appendChild(details);
+  card.appendChild(info);
+  return card;
+}
+
+function createDetailItem(label, value) {
+  const item = document.createElement('div');
+  item.className = 'detail-item';
+  item.dataset.label = label;
+  
+  const labelSpan = document.createElement('span');
+  labelSpan.className = 'detail-label';
+  labelSpan.textContent = label;
+  
+  const valueSpan = document.createElement('span');
+  valueSpan.className = 'detail-value';
+  valueSpan.textContent = value;
+  
+  item.appendChild(labelSpan);
+  item.appendChild(valueSpan);
+  
+  return item;
+}

client/src/ui/requestFilters.js

@@ -0,0 +1,227 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+import {
+  saveRequestTypes,
+  saveRequestStatuses,
+  saveRequestSort,
+  saveRequestSearch
+} from '../utils/storage.js';
+import { renderRequests } from './requests.js';
+
+// ---- Type filter dropdown ----
+
+function initTypeFilter() {
+  const btn = document.getElementById('request-type-filter-btn');
+  const dropdown = document.getElementById('request-type-filter-dropdown');
+  const selectAll = document.getElementById('request-type-select-all');
+  const deselectAll = document.getElementById('request-type-deselect-all');
+
+  if (!btn || !dropdown) return;
+
+  btn.addEventListener('click', (e) => {
+    e.stopPropagation();
+    dropdown.classList.toggle('open');
+  });
+
+  selectAll?.addEventListener('click', () => setAllTypes(true));
+  deselectAll?.addEventListener('click', () => setAllTypes(false));
+
+  // Wire up checkboxes
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  checkboxes.forEach(cb => {
+    cb.addEventListener('change', () => {
+      const value = cb.closest('.request-filter-option').dataset.value;
+      toggleType(value, cb.checked);
+    });
+  });
+
+  updateTypeFilterUI();
+}
+
+function setAllTypes(checked) {
+  const dropdown = document.getElementById('request-type-filter-dropdown');
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  const newTypes = [];
+  checkboxes.forEach(cb => {
+    cb.checked = checked;
+    if (checked) newTypes.push(cb.closest('.request-filter-option').dataset.value);
+  });
+  state.selectedRequestTypes = checked ? newTypes : [];
+  saveRequestTypes(state.selectedRequestTypes);
+  updateTypeFilterUI();
+  renderRequests();
+}
+
+function toggleType(value, checked) {
+  const idx = state.selectedRequestTypes.indexOf(value);
+  if (checked && idx === -1) {
+    state.selectedRequestTypes.push(value);
+  } else if (!checked && idx > -1) {
+    state.selectedRequestTypes.splice(idx, 1);
+  }
+  saveRequestTypes(state.selectedRequestTypes);
+  updateTypeFilterUI();
+  renderRequests();
+}
+
+function updateTypeFilterUI() {
+  const text = document.getElementById('request-type-selected-text');
+  if (!text) return;
+
+  const dropdown = document.getElementById('request-type-filter-dropdown');
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  checkboxes.forEach(cb => {
+    const value = cb.closest('.request-filter-option').dataset.value;
+    cb.checked = state.selectedRequestTypes.includes(value);
+  });
+
+  if (state.selectedRequestTypes.length === 0) {
+    text.textContent = 'All';
+  } else if (state.selectedRequestTypes.length === checkboxes.length) {
+    text.textContent = 'All';
+  } else {
+    text.textContent = state.selectedRequestTypes.length;
+  }
+}
+
+// ---- Status filter dropdown ----
+
+function initStatusFilter() {
+  const btn = document.getElementById('request-status-filter-btn');
+  const dropdown = document.getElementById('request-status-filter-dropdown');
+  const selectAll = document.getElementById('request-status-select-all');
+  const deselectAll = document.getElementById('request-status-deselect-all');
+
+  if (!btn || !dropdown) return;
+
+  btn.addEventListener('click', (e) => {
+    e.stopPropagation();
+    dropdown.classList.toggle('open');
+  });
+
+  selectAll?.addEventListener('click', () => setAllStatuses(true));
+  deselectAll?.addEventListener('click', () => setAllStatuses(false));
+
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  checkboxes.forEach(cb => {
+    cb.addEventListener('change', () => {
+      const value = cb.closest('.request-filter-option').dataset.value;
+      toggleStatus(value, cb.checked);
+    });
+  });
+
+  updateStatusFilterUI();
+}
+
+function setAllStatuses(checked) {
+  const dropdown = document.getElementById('request-status-filter-dropdown');
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  const newStatuses = [];
+  checkboxes.forEach(cb => {
+    cb.checked = checked;
+    if (checked) newStatuses.push(cb.closest('.request-filter-option').dataset.value);
+  });
+  state.selectedRequestStatuses = checked ? newStatuses : [];
+  saveRequestStatuses(state.selectedRequestStatuses);
+  updateStatusFilterUI();
+  renderRequests();
+}
+
+function toggleStatus(value, checked) {
+  const idx = state.selectedRequestStatuses.indexOf(value);
+  if (checked && idx === -1) {
+    state.selectedRequestStatuses.push(value);
+  } else if (!checked && idx > -1) {
+    state.selectedRequestStatuses.splice(idx, 1);
+  }
+  saveRequestStatuses(state.selectedRequestStatuses);
+  updateStatusFilterUI();
+  renderRequests();
+}
+
+function updateStatusFilterUI() {
+  const text = document.getElementById('request-status-selected-text');
+  if (!text) return;
+
+  const dropdown = document.getElementById('request-status-filter-dropdown');
+  const checkboxes = dropdown.querySelectorAll('.request-filter-checkbox');
+  checkboxes.forEach(cb => {
+    const value = cb.closest('.request-filter-option').dataset.value;
+    cb.checked = state.selectedRequestStatuses.includes(value);
+  });
+
+  if (state.selectedRequestStatuses.length === 0) {
+    text.textContent = 'All';
+  } else if (state.selectedRequestStatuses.length === checkboxes.length) {
+    text.textContent = 'All';
+  } else {
+    text.textContent = state.selectedRequestStatuses.length;
+  }
+}
+
+// ---- Sort select ----
+
+function initSortSelect() {
+  const select = document.getElementById('request-sort-select');
+  if (!select) return;
+
+  select.value = state.requestSortMode;
+  select.addEventListener('change', (e) => {
+    state.requestSortMode = e.target.value;
+    saveRequestSort(state.requestSortMode);
+    renderRequests();
+  });
+}
+
+// ---- Search input ----
+
+function initSearchInput() {
+  const input = document.getElementById('request-search-input');
+  if (!input) return;
+
+  input.value = state.requestSearchQuery;
+
+  let debounceTimer;
+  input.addEventListener('input', (e) => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      state.requestSearchQuery = e.target.value;
+      saveRequestSearch(state.requestSearchQuery);
+      renderRequests();
+    }, 200);
+  });
+}
+
+// ---- Global click-outside handler ----
+
+function initClickOutside() {
+  document.addEventListener('click', (e) => {
+    const typeDropdown = document.getElementById('request-type-filter-dropdown');
+    const typeBtn = document.getElementById('request-type-filter-btn');
+    const statusDropdown = document.getElementById('request-status-filter-dropdown');
+    const statusBtn = document.getElementById('request-status-filter-btn');
+
+    if (typeDropdown && !typeDropdown.contains(e.target) && e.target !== typeBtn && !typeBtn?.contains(e.target)) {
+      typeDropdown.classList.remove('open');
+    }
+    if (statusDropdown && !statusDropdown.contains(e.target) && e.target !== statusBtn && !statusBtn?.contains(e.target)) {
+      statusDropdown.classList.remove('open');
+    }
+  });
+}
+
+// ---- Public API ----
+
+export function initRequestFilters() {
+  initTypeFilter();
+  initStatusFilter();
+  initSortSelect();
+  initSearchInput();
+  initClickOutside();
+
+  // Listen for SSE updates (registered once on app bootstrap)
+  document.addEventListener('ombiRequestsUpdated', () => {
+    renderRequests();
+  });
+}

client/src/ui/requests.js

@@ -0,0 +1,255 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+import { escapeHtml } from '../utils/format.js';
+import { applyRequestFilters, getRequestStatus } from '../utils/ombiFilters.js';
+
+/**
+ * Helper function to extract the username from an Ombi request object.
+ * The Ombi API returns requestedUser as an OmbiStore.Entities.OmbiUser object,
+ * not a string, so we need to extract the username from the object.
+ *
+ * Must stay in sync with server/utils/ombiHelpers.js
+ *
+ * @param {Object} request - The Ombi request object
+ * @returns {string} The extracted username, or empty string if not found
+ */
+function extractRequestedUser(request) {
+  if (!request) return '';
+
+  // Try to locate a user object or string from various fields common to Ombi Movies and TV shows
+  const userSource = request.requestedUser || request.RequestedUser ||
+                     request.user || request.User ||
+                     request.requestedBy || request.RequestedBy ||
+                     request.ombiUser || request.OmbiUser ||
+                     request.requestedByUser || request.RequestedByUser;
+
+  // If userSource is an object, extract key fields
+  if (userSource && typeof userSource === 'object') {
+    const username = userSource.alias || userSource.Alias ||
+                     userSource.userAlias || userSource.UserAlias ||
+                     userSource.userName || userSource.UserName ||
+                     userSource.normalizedUserName || userSource.NormalizedUserName ||
+                     userSource.displayName || userSource.DisplayName ||
+                     userSource.email || userSource.Email;
+    if (username) return username;
+  }
+
+  // If userSource is a string
+  if (userSource && typeof userSource === 'string') {
+    return userSource;
+  }
+
+  // Fallbacks on the request root level
+  const rootFallback = request.requestedByAlias || request.RequestedByAlias ||
+                       request.requestedByUsername || request.RequestedByUsername ||
+                       request.requester || request.Requester ||
+                       request.requestedByEmail || request.RequestedByEmail;
+  if (rootFallback) return rootFallback;
+
+  // Check seasons / childRequests nested arrays (common for Ombi TV show requests)
+  if (Array.isArray(request.seasons)) {
+    for (const season of request.seasons) {
+      const seasonUser = extractRequestedUser(season);
+      if (seasonUser) return seasonUser;
+    }
+  }
+  
+  if (Array.isArray(request.childRequests)) {
+    for (const child of request.childRequests) {
+      const childUser = extractRequestedUser(child);
+      if (childUser) return childUser;
+    }
+  }
+
+  return '';
+}
+
+export function renderRequests() {
+  const requestsList = document.getElementById('requests-list');
+  const noRequests = document.getElementById('no-requests');
+
+  if (!requestsList) return;
+
+  const ombiRequests = state.ombiRequests || { movie: [], tv: [] };
+  const allRequests = [
+    ...ombiRequests.movie.map(r => ({ ...r, mediaType: 'movie' })),
+    ...ombiRequests.tv.map(r => ({ ...r, mediaType: 'tv' }))
+  ];
+
+  // Apply client-side filters, sorting, and search
+  const filtered = applyRequestFilters(allRequests, {
+    types: state.selectedRequestTypes,
+    statuses: state.selectedRequestStatuses,
+    sort: state.requestSortMode,
+    search: state.requestSearchQuery
+  });
+
+  requestsList.innerHTML = '';
+
+  if (filtered.length === 0) {
+    if (noRequests) {
+      noRequests.style.display = 'block';
+      const p = noRequests.querySelector('p');
+      if (p) {
+        // Differentiate between no data from Ombi vs filters excluded everything
+        const hasAnyData = allRequests.length > 0;
+        p.textContent = hasAnyData
+          ? 'No requests match your filters.'
+          : 'No requests found.';
+      }
+    }
+    return;
+  }
+
+  if (noRequests) noRequests.style.display = 'none';
+
+  filtered.forEach(request => {
+    const card = createRequestCard(request);
+    requestsList.appendChild(card);
+  });
+}
+
+function createRequestCard(request) {
+  if (!request) {
+    const card = document.createElement('div');
+    card.className = 'request-card';
+    card.textContent = 'Invalid request data';
+    return card;
+  }
+
+  const card = document.createElement('div');
+  card.className = `request-card ${request.mediaType || ''}`;
+
+  const typeIcon = document.createElement('span');
+  typeIcon.className = `request-type-icon ${request.mediaType || ''}`;
+  typeIcon.textContent = request.mediaType === 'movie' ? '🎬' : '📺';
+
+  const content = document.createElement('div');
+  content.className = 'request-content';
+
+  const title = document.createElement('div');
+  title.className = 'request-title';
+  title.textContent = request.title || 'Unknown Title';
+
+  const meta = document.createElement('div');
+  meta.className = 'request-meta';
+
+  const statusBadge = createStatusBadge(request);
+  meta.appendChild(statusBadge);
+
+  if (request.year) {
+    const year = document.createElement('span');
+    year.className = 'request-year';
+    year.textContent = request.year;
+    meta.appendChild(year);
+  }
+
+  const username = extractRequestedUser(request);
+  const user = document.createElement('span');
+  user.className = 'request-user';
+  if (username) {
+    user.textContent = `Requested by: ${username}`;
+  } else {
+    user.textContent = 'Requested by: Unknown (Ombi)';
+    user.title = 'No user information received from Ombi';
+    user.style.cursor = 'help';
+    user.style.textDecoration = 'underline dotted';
+  }
+  meta.appendChild(user);
+
+  const childDate = request.childRequests && request.childRequests[0] ? (request.childRequests[0].requestedDate || request.childRequests[0].RequestedDate) : null;
+  const dateStr = request.requestedDate || request.RequestedDate || request.date || request.Date || childDate;
+  if (dateStr) {
+    const requestDate = document.createElement('span');
+    requestDate.className = 'request-date';
+    try {
+      const dateObj = new Date(dateStr);
+      if (!isNaN(dateObj.getTime())) {
+        const year = dateObj.getFullYear();
+        const month = String(dateObj.getMonth() + 1).padStart(2, '0');
+        const day = String(dateObj.getDate()).padStart(2, '0');
+        const hours = String(dateObj.getHours()).padStart(2, '0');
+        const minutes = String(dateObj.getMinutes()).padStart(2, '0');
+        requestDate.textContent = `Date: ${year}-${month}-${day} ${hours}:${minutes}`;
+      } else {
+        requestDate.textContent = `Date: ${dateStr}`;
+      }
+    } catch (e) {
+      requestDate.textContent = `Date: ${dateStr}`;
+    }
+    meta.appendChild(requestDate);
+  }
+
+  if (request.quality) {
+    const quality = document.createElement('span');
+    quality.className = 'request-quality';
+    quality.textContent = request.quality;
+    meta.appendChild(quality);
+  }
+
+  content.appendChild(title);
+  content.appendChild(meta);
+
+  const actions = document.createElement('span');
+  actions.className = 'service-icons-container';
+
+  const id = request.theTvDbId || request.theTvdbId || request.tvDbId || request.tvdbId || request.TvDbId || request.TheTvDbId || request.theMovieDbId || request.theTmdbId || request.imdbId || request.ImdbId;
+  if (state.ombiBaseUrl && id) {
+    const ombiLink = document.createElement('a');
+    ombiLink.className = 'ombi-link';
+    ombiLink.href = `${state.ombiBaseUrl}/details/${request.mediaType || 'movie'}/${id}`;
+    ombiLink.target = '_blank';
+    ombiLink.title = 'View in Ombi';
+    
+    const ombiIcon = document.createElement('img');
+    ombiIcon.className = 'service-icon ombi';
+    ombiIcon.src = '/images/ombi.svg';
+    ombiIcon.alt = 'Ombi';
+    
+    ombiLink.appendChild(ombiIcon);
+    actions.appendChild(ombiLink);
+  }
+
+  if (state.isAdmin && request.arrLink) {
+    const arrLink = document.createElement('a');
+    arrLink.className = `${request.arrType}-link`;
+    arrLink.href = request.arrLink;
+    arrLink.target = '_blank';
+    arrLink.title = `View in ${request.arrType === 'sonarr' ? 'Sonarr' : 'Radarr'}`;
+    
+    const arrIcon = document.createElement('img');
+    arrIcon.className = `service-icon ${request.arrType}`;
+    arrIcon.src = request.arrType === 'sonarr' ? '/images/sonarr.svg' : '/images/radarr.svg';
+    arrIcon.alt = request.arrType === 'sonarr' ? 'Sonarr' : 'Radarr';
+    
+    arrLink.appendChild(arrIcon);
+    actions.appendChild(arrLink);
+  }
+
+  card.appendChild(typeIcon);
+  card.appendChild(content);
+  card.appendChild(actions);
+
+  return card;
+}
+
+function createStatusBadge(request) {
+  const badge = document.createElement('span');
+  badge.className = 'request-status-badge';
+
+  const status = getRequestStatus(request);
+  const statusTexts = {
+    available: 'Available',
+    denied: `Denied: ${request.deniedReason || 'No reason'}`,
+    approved: 'Approved',
+    pending: 'Pending',
+    unknown: 'Unknown'
+  };
+
+  badge.classList.add(status);
+  badge.textContent = statusTexts[status] || 'Unknown';
+
+  return badge;
+}
+

client/src/ui/statusPanel.js

@@ -0,0 +1,203 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state, STATUS_REFRESH_MS } from '../state.js';
+import { refreshStatusPanel as apiRefreshStatusPanel } from '../api.js';
+import { fetchWebhookStatus } from './webhooks.js';
+
+export async function toggleStatusPanel() {
+  const panel = document.getElementById('status-panel');
+  const webhooksSection = document.getElementById('webhooks-section');
+  if (!panel.classList.contains('hidden')) {
+    // Close both panels (webhooks is a sibling, hide it too)
+    panel.classList.add('hidden');
+    if (webhooksSection) webhooksSection.classList.add('hidden');
+    if (state.statusRefreshHandle) { clearInterval(state.statusRefreshHandle); state.statusRefreshHandle = null; }
+    return;
+  }
+  // Open status panel and webhooks section (siblings)
+  panel.classList.remove('hidden');
+  // Show webhooks section for admin users (collapsed by default)
+  if (webhooksSection && state.isAdmin) {
+    webhooksSection.classList.remove('hidden');
+    state.webhookSectionExpanded = false;
+    document.getElementById('webhooks-content').classList.add('hidden');
+    document.getElementById('webhooks-toggle').classList.remove('expanded');
+    await fetchWebhookStatus();
+  } else if (webhooksSection) {
+    webhooksSection.classList.add('hidden');
+  }
+  refreshStatusPanel();
+  if (state.statusRefreshHandle) clearInterval(state.statusRefreshHandle);
+  state.statusRefreshHandle = setInterval(refreshStatusPanel, STATUS_REFRESH_MS);
+}
+
+export function closeStatusPanel() {
+  document.getElementById('status-panel').classList.add('hidden');
+  const webhooksSection = document.getElementById('webhooks-section');
+  if (webhooksSection) webhooksSection.classList.add('hidden');
+  if (state.statusRefreshHandle) { clearInterval(state.statusRefreshHandle); state.statusRefreshHandle = null; }
+}
+
+export async function refreshStatusPanel() {
+  const panel = document.getElementById('status-panel');
+  const contentDiv = document.getElementById('status-content');
+  console.log('[Status] panel found:', !!panel, 'contentDiv found:', !!contentDiv, 'panel display:', panel?.style?.display);
+  if (!panel || panel.classList.contains('hidden')) return;
+  console.log('[Status] Refreshing status panel...');
+  try {
+    const result = await apiRefreshStatusPanel();
+    if (result.success) {
+      console.log('[Status] Got status data, rendering...');
+      renderStatusPanel(result.data, panel);
+    } else {
+      console.error('[Status] API returned error:', result.error);
+      if (contentDiv && (!contentDiv.innerHTML || contentDiv.innerHTML.includes('status-loading'))) {
+        contentDiv.innerHTML = '<p class="status-error">Failed to load status: ' + result.error + '</p>';
+      }
+    }
+  } catch (err) {
+    console.error('[Status] Error fetching status:', err);
+    // Don't overwrite panel on transient error during auto-refresh
+    if (contentDiv && (!contentDiv.innerHTML || contentDiv.innerHTML.includes('status-loading'))) {
+      contentDiv.innerHTML = '<p class="status-error">Failed to load status: ' + err.message + '</p>';
+    }
+  }
+}
+
+export function renderStatusPanel(data, panel) {
+  console.log('[Status] renderStatusPanel called with data:', data ? 'yes' : 'no', 'keys:', data ? Object.keys(data) : 'none');
+  const s = data.server;
+  const hrs = Math.floor(s.uptimeSeconds / 3600);
+  const mins = Math.floor((s.uptimeSeconds % 3600) / 60);
+  const secs = s.uptimeSeconds % 60;
+  const uptime = `${hrs}h ${mins}m ${secs}s`;
+
+  const totalKB = (data.cache.totalSizeBytes / 1024).toFixed(1);
+
+  let html = `
+    <div class="status-header">
+      <h3>Server Status</h3>
+      <button class="status-close" id="status-close-btn">&times;</button>
+    </div>
+    <div class="status-grid">
+      <div class="status-card">
+        <div class="status-card-title">Server</div>
+        <div class="status-row"><span>Uptime</span><span>${uptime}</span></div>
+        <div class="status-row"><span>Node</span><span>${escapeHtml(s.nodeVersion)}</span></div>
+        <div class="status-row"><span>Memory (RSS)</span><span>${s.memoryUsageMB} MB</span></div>
+        <div class="status-row"><span>Heap</span><span>${s.heapUsedMB} / ${s.heapTotalMB} MB</span></div>
+      </div>
+      <div class="status-card">
+        <div class="status-card-title">Data Refresh</div>`;
+
+  const pollIntervalMs = data.polling.intervalMs;
+  const clients = data.clients || [];
+  const sseClients = clients.filter(c => c.type === 'sse');
+
+  if (data.polling.enabled) {
+    html += `<div class="status-row"><span>Background poll</span><span>${pollIntervalMs / 1000}s</span></div>`;
+  } else {
+    html += `<div class="status-row"><span>Background poll</span><span>Disabled</span></div>`;
+  }
+
+  const mode = sseClients.length > 0
+    ? `<span class="status-fg-badge">SSE push</span>`
+    : (data.polling.enabled ? 'Background' : 'On-demand (idle)');
+  html += `<div class="status-row"><span>Delivery mode</span><span>${mode}</span></div>`;
+
+  html += `<div class="status-row"><span>SSE clients</span><span>${sseClients.length}</span></div>`;
+  for (const c of sseClients) {
+    const age = Math.round((Date.now() - c.connectedAt) / 1000);
+    html += `<div class="status-row status-row-sub"><span>${escapeHtml(c.user)}</span><span>connected ${age}s ago</span></div>`;
+  }
+
+  html += `</div>`;
+
+  // Webhook metrics card (admin only)
+  if (state.isAdmin && data.webhooks) {
+    const wh = data.webhooks;
+    const sonarrEnabled = wh.sonarr?.enabled ? '●' : '○';
+    const radarrEnabled = wh.radarr?.enabled ? '●' : '○';
+    const ombiEnabled = wh.ombi?.enabled ? '●' : '○';
+    const sonarrEvents = wh.sonarr?.eventsReceived || 0;
+    const radarrEvents = wh.radarr?.eventsReceived || 0;
+    const ombiEvents = wh.ombi?.eventsReceived || 0;
+    const sonarrPolls = wh.sonarr?.pollsSkipped || 0;
+    const radarrPolls = wh.radarr?.pollsSkipped || 0;
+    const ombiPolls = wh.ombi?.pollsSkipped || 0;
+
+    html += `
+      <div class="status-card">
+        <div class="status-card-title">Webhooks</div>
+        <div class="status-row"><span>Sonarr</span><span>${sonarrEnabled} ${wh.sonarr?.enabled ? 'Enabled' : 'Disabled'}</span></div>
+        <div class="status-row"><span>Radarr</span><span>${radarrEnabled} ${wh.radarr?.enabled ? 'Enabled' : 'Disabled'}</span></div>
+        <div class="status-row"><span>Ombi</span><span>${ombiEnabled} ${wh.ombi?.enabled ? 'Enabled' : 'Disabled'}</span></div>
+        <div class="status-row status-row-sub"><span>Events</span><span>S:${sonarrEvents} R:${radarrEvents} O:${ombiEvents}</span></div>
+        <div class="status-row status-row-sub"><span>Polls skipped</span><span>S:${sonarrPolls} R:${radarrPolls} O:${ombiPolls}</span></div>
+      </div>`;
+  }
+
+  // Poll timings card
+  const lp = data.polling.lastPoll;
+  if (lp) {
+    const pollAge = Math.round((Date.now() - new Date(lp.timestamp).getTime()) / 1000);
+    html += `
+      <div class="status-card status-card-wide">
+        <div class="status-card-title">Last Poll (${lp.totalMs}ms total, ${pollAge}s ago)</div>
+        <div class="status-timings">`;
+    const maxTaskMs = lp.tasks.reduce((max, t) => Math.max(max, t.ms), 1);
+    for (const t of lp.tasks) {
+      const barWidth = Math.max(2, (t.ms / maxTaskMs) * 100);
+      html += `
+          <div class="timing-row">
+            <span class="timing-label">${escapeHtml(t.label)}</span>
+            <div class="timing-bar-bg"><div class="timing-bar" data-w="${barWidth.toFixed(1)}"></div></div>
+            <span class="timing-value">${t.ms}ms</span>
+          </div>`;
+    }
+    html += `</div></div>`;
+  }
+
+  // Cache table
+  html += `
+      <div class="status-card status-card-wide">
+        <div class="status-card-title">Cache (${data.cache.entryCount} entries, ${totalKB} KB)</div>
+        <table class="status-table">
+          <thead><tr><th>Key</th><th>Items</th><th>Size</th><th>TTL</th></tr></thead>
+          <tbody>`;
+
+  for (const e of data.cache.entries) {
+    const sizeStr = e.sizeBytes > 1024 ? (e.sizeBytes / 1024).toFixed(1) + ' KB' : e.sizeBytes + ' B';
+    const ttlStr = e.expired ? '<span class="status-expired">expired</span>' : (e.ttlRemainingMs / 1000).toFixed(0) + 's';
+    const items = e.itemCount !== null ? e.itemCount : '—';
+    html += `<tr><td><code>${escapeHtml(e.key)}</code></td><td>${items}</td><td>${sizeStr}</td><td>${ttlStr}</td></tr>`;
+  }
+
+  html += `</tbody></table></div></div>`;
+  // Render into status-content div, not the whole panel (preserves webhooks section)
+  const contentDiv = document.getElementById('status-content');
+  const panelCheck = document.getElementById('status-panel');
+  console.log('[Status] contentDiv found:', !!contentDiv, 'panel children:', panelCheck?.children?.length, 'HTML length:', html.length);
+  if (panelCheck) {
+    console.log('[Status] panel innerHTML preview:', panelCheck.innerHTML.substring(0, 200));
+  }
+  if (contentDiv) {
+    contentDiv.innerHTML = html;
+    console.log('[Status] HTML rendered, contentDiv innerHTML length:', contentDiv.innerHTML.length);
+  } else {
+    console.error('[Status] contentDiv not found!');
+  }
+  // Wire close button — addEventListener avoids CSP inline handler restrictions
+  const closeBtn = document.getElementById('status-close-btn');
+  if (closeBtn) closeBtn.addEventListener('click', closeStatusPanel);
+  // Set bar widths via JS DOM assignment — immune to CSP style-src restrictions
+  panel.querySelectorAll('.timing-bar[data-w]').forEach(el => {
+    el.style.width = el.dataset.w + '%';
+  });
+}
+
+function escapeHtml(str) {
+  const div = document.createElement('div');
+  div.textContent = str;
+  return div.innerHTML;
+}

client/src/ui/tabs.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { getActiveTab, saveActiveTab } from '../utils/storage.js';
+import { loadHistory } from './history.js';
+import { renderRequests } from './requests.js';
+
+export function initTabs() {
+  const downloadsTab = document.querySelector('[data-tab="downloads"]');
+  const requestsTab = document.querySelector('[data-tab="requests"]');
+  const historyTab = document.querySelector('[data-tab="history"]');
+  
+  if (!downloadsTab || !historyTab) return;
+  
+  // Load saved tab
+  const savedTab = getActiveTab();
+  if (savedTab === 'requests') {
+    activateTab('requests');
+  } else if (savedTab === 'history') {
+    activateTab('history');
+  } else {
+    activateTab('downloads');
+  }
+  
+  downloadsTab.addEventListener('click', () => activateTab('downloads'));
+  if (requestsTab) {
+    requestsTab.addEventListener('click', () => activateTab('requests'));
+  }
+  historyTab.addEventListener('click', () => activateTab('history'));
+}
+
+export function activateTab(tab) {
+  const downloadsTab = document.querySelector('[data-tab="downloads"]');
+  const requestsTab = document.querySelector('[data-tab="requests"]');
+  const historyTab = document.querySelector('[data-tab="history"]');
+  const downloadsSection = document.getElementById('tab-downloads');
+  const requestsSection = document.getElementById('tab-requests');
+  const historySection = document.getElementById('tab-history');
+  
+  // Remove active class from all tabs
+  if (downloadsTab) downloadsTab.classList.remove('active');
+  if (requestsTab) requestsTab.classList.remove('active');
+  if (historyTab) historyTab.classList.remove('active');
+  
+  // Hide all sections
+  if (downloadsSection) downloadsSection.classList.add('hidden');
+  if (requestsSection) requestsSection.classList.add('hidden');
+  if (historySection) historySection.classList.add('hidden');
+  
+  if (tab === 'downloads') {
+    if (downloadsTab) downloadsTab.classList.add('active');
+    if (downloadsSection) downloadsSection.classList.remove('hidden');
+    saveActiveTab('downloads');
+  } else if (tab === 'requests') {
+    if (requestsTab) requestsTab.classList.add('active');
+    if (requestsSection) requestsSection.classList.remove('hidden');
+    saveActiveTab('requests');
+    renderRequests();
+  } else if (tab === 'history') {
+    if (historyTab) historyTab.classList.add('active');
+    if (historySection) historySection.classList.remove('hidden');
+    saveActiveTab('history');
+    loadHistory();
+  }
+}
+
+export function goHome() {
+  activateTab('downloads');
+}

client/src/ui/theme.js

@@ -0,0 +1,46 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { getTheme, saveTheme } from '../utils/storage.js';
+
+// Apply saved theme immediately on load
+(function applyTheme() {
+  const theme = getTheme() || 'light';
+  document.documentElement.setAttribute('data-theme', theme);
+})();
+
+export function initThemeSwitcher() {
+  const themeButtons = document.querySelectorAll('.theme-btn');
+  const currentTheme = getTheme() || 'light';
+  
+  // Set initial active state on buttons
+  themeButtons.forEach(btn => {
+    if (btn.getAttribute('data-theme') === currentTheme) {
+      btn.classList.add('active');
+    } else {
+      btn.classList.remove('active');
+    }
+    
+    btn.addEventListener('click', () => {
+      const theme = btn.getAttribute('data-theme');
+      if (theme) {
+        setTheme(theme);
+      }
+    });
+  });
+}
+
+export function setTheme(theme) {
+  document.documentElement.setAttribute('data-theme', theme);
+  saveTheme(theme);
+  
+  // Sync button active classes if elements are present on the page
+  const themeButtons = document.querySelectorAll('.theme-btn');
+  themeButtons.forEach(btn => {
+    if (btn.getAttribute('data-theme') === theme) {
+      btn.classList.add('active');
+    } else {
+      btn.classList.remove('active');
+    }
+  });
+}
+

client/src/ui/webhooks.js

@@ -0,0 +1,292 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+import { fetchWebhookStatus as apiFetchWebhookStatus, enableSonarrWebhook as apiEnableSonarrWebhook, enableRadarrWebhook as apiEnableRadarrWebhook, enableOmbiWebhook as apiEnableOmbiWebhook, testSonarrWebhook as apiTestSonarrWebhook, testRadarrWebhook as apiTestRadarrWebhook, testOmbiWebhook as apiTestOmbiWebhook } from '../api.js';
+import { formatTimeAgo } from '../utils/format.js';
+
+export function initWebhooks() {
+  const webhooksSection = document.getElementById('webhooks-section');
+  if (!webhooksSection) return;
+  
+  // Note: visibility is controlled by showDashboard() based on isAdmin
+  
+  document.getElementById('webhooks-header').addEventListener('click', toggleWebhookSection);
+  document.getElementById('enable-sonarr-webhook').addEventListener('click', enableSonarrWebhook);
+  document.getElementById('enable-radarr-webhook').addEventListener('click', enableRadarrWebhook);
+  document.getElementById('enable-ombi-webhook').addEventListener('click', enableOmbiWebhook);
+  document.getElementById('test-sonarr-webhook').addEventListener('click', testSonarrWebhook);
+  document.getElementById('test-radarr-webhook').addEventListener('click', testRadarrWebhook);
+  document.getElementById('test-ombi-webhook').addEventListener('click', testOmbiWebhook);
+}
+
+export function toggleWebhookSection() {
+  state.webhookSectionExpanded = !state.webhookSectionExpanded;
+  const content = document.getElementById('webhooks-content');
+  const toggle = document.getElementById('webhooks-toggle');
+  
+  if (state.webhookSectionExpanded) {
+    content.classList.remove('hidden');
+  } else {
+    content.classList.add('hidden');
+  }
+  toggle.classList.toggle('expanded', state.webhookSectionExpanded);
+  
+  if (state.webhookSectionExpanded) {
+    fetchWebhookStatus();
+  }
+}
+
+export async function fetchWebhookStatus() {
+  const loadingEl = document.getElementById('webhook-loading');
+  loadingEl.classList.remove('hidden');
+  
+  try {
+    const result = await apiFetchWebhookStatus();
+    if (result.success) {
+      renderWebhookStatus();
+    }
+  } catch (err) {
+    console.error('Failed to fetch webhook status:', err);
+  } finally {
+    loadingEl.classList.add('hidden');
+  }
+}
+
+export function renderWebhookStatus() {
+  // Sonarr
+  const sonarrStatus = document.getElementById('sonarr-status');
+  const sonarrEnableBtn = document.getElementById('enable-sonarr-webhook');
+  const sonarrTestBtn = document.getElementById('test-sonarr-webhook');
+  const sonarrTriggers = document.getElementById('sonarr-triggers');
+  const sonarrStats = document.getElementById('sonarr-stats');
+  
+  sonarrStatus.textContent = state.sonarrWebhook.enabled ? '● Enabled' : '○ Disabled';
+  sonarrStatus.className = 'status-indicator ' + (state.sonarrWebhook.enabled ? 'enabled' : 'disabled');
+  if (state.sonarrWebhook.enabled) {
+    sonarrEnableBtn.classList.add('hidden');
+    sonarrTestBtn.classList.remove('hidden');
+    sonarrTriggers.classList.remove('hidden');
+  } else {
+    sonarrEnableBtn.classList.remove('hidden');
+    sonarrTestBtn.classList.add('hidden');
+    sonarrTriggers.classList.add('hidden');
+  }
+  
+  if (state.sonarrWebhook.enabled) {
+    document.getElementById('sonarr-onGrab').textContent = state.sonarrWebhook.triggers.onGrab ? '✓' : '✗';
+    document.getElementById('sonarr-onGrab').className = 'trigger-value ' + (state.sonarrWebhook.triggers.onGrab ? 'active' : 'inactive');
+    document.getElementById('sonarr-onDownload').textContent = state.sonarrWebhook.triggers.onDownload ? '✓' : '✗';
+    document.getElementById('sonarr-onDownload').className = 'trigger-value ' + (state.sonarrWebhook.triggers.onDownload ? 'active' : 'inactive');
+    document.getElementById('sonarr-onImport').textContent = state.sonarrWebhook.triggers.onImport ? '✓' : '✗';
+    document.getElementById('sonarr-onImport').className = 'trigger-value ' + (state.sonarrWebhook.triggers.onImport ? 'active' : 'inactive');
+    document.getElementById('sonarr-onUpgrade').textContent = state.sonarrWebhook.triggers.onUpgrade ? '✓' : '✗';
+    document.getElementById('sonarr-onUpgrade').className = 'trigger-value ' + (state.sonarrWebhook.triggers.onUpgrade ? 'active' : 'inactive');
+  }
+  
+  if (state.sonarrWebhook.stats) {
+    sonarrStats.classList.remove('hidden');
+    document.getElementById('sonarr-events').textContent = state.sonarrWebhook.stats.eventsReceived ?? 0;
+    document.getElementById('sonarr-polls').textContent = state.sonarrWebhook.stats.pollsSkipped ?? 0;
+    document.getElementById('sonarr-last').textContent = formatTimeAgo(state.sonarrWebhook.stats.lastWebhookTimestamp);
+  } else {
+    sonarrStats.classList.add('hidden');
+  }
+  
+  // Radarr
+  const radarrStatus = document.getElementById('radarr-status');
+  const radarrEnableBtn = document.getElementById('enable-radarr-webhook');
+  const radarrTestBtn = document.getElementById('test-radarr-webhook');
+  const radarrTriggers = document.getElementById('radarr-triggers');
+  const radarrStats = document.getElementById('radarr-stats');
+  
+  radarrStatus.textContent = state.radarrWebhook.enabled ? '● Enabled' : '○ Disabled';
+  radarrStatus.className = 'status-indicator ' + (state.radarrWebhook.enabled ? 'enabled' : 'disabled');
+  if (state.radarrWebhook.enabled) {
+    radarrEnableBtn.classList.add('hidden');
+    radarrTestBtn.classList.remove('hidden');
+    radarrTriggers.classList.remove('hidden');
+  } else {
+    radarrEnableBtn.classList.remove('hidden');
+    radarrTestBtn.classList.add('hidden');
+    radarrTriggers.classList.add('hidden');
+  }
+  
+  if (state.radarrWebhook.enabled) {
+    document.getElementById('radarr-onGrab').textContent = state.radarrWebhook.triggers.onGrab ? '✓' : '✗';
+    document.getElementById('radarr-onGrab').className = 'trigger-value ' + (state.radarrWebhook.triggers.onGrab ? 'active' : 'inactive');
+    document.getElementById('radarr-onDownload').textContent = state.radarrWebhook.triggers.onDownload ? '✓' : '✗';
+    document.getElementById('radarr-onDownload').className = 'trigger-value ' + (state.radarrWebhook.triggers.onDownload ? 'active' : 'inactive');
+    document.getElementById('radarr-onImport').textContent = state.radarrWebhook.triggers.onImport ? '✓' : '✗';
+    document.getElementById('radarr-onImport').className = 'trigger-value ' + (state.radarrWebhook.triggers.onImport ? 'active' : 'inactive');
+    document.getElementById('radarr-onUpgrade').textContent = state.radarrWebhook.triggers.onUpgrade ? '✓' : '✗';
+    document.getElementById('radarr-onUpgrade').className = 'trigger-value ' + (state.radarrWebhook.triggers.onUpgrade ? 'active' : 'inactive');
+  }
+  
+  if (state.radarrWebhook.stats) {
+    radarrStats.classList.remove('hidden');
+    document.getElementById('radarr-events').textContent = state.radarrWebhook.stats.eventsReceived ?? 0;
+    document.getElementById('radarr-polls').textContent = state.radarrWebhook.stats.pollsSkipped ?? 0;
+    document.getElementById('radarr-last').textContent = formatTimeAgo(state.radarrWebhook.stats.lastWebhookTimestamp);
+  } else {
+    radarrStats.classList.add('hidden');
+  }
+
+  // Ombi
+  const ombiStatus = document.getElementById('ombi-status');
+  const ombiEnableBtn = document.getElementById('enable-ombi-webhook');
+  const ombiTestBtn = document.getElementById('test-ombi-webhook');
+  const ombiTriggers = document.getElementById('ombi-triggers');
+  const ombiStats = document.getElementById('ombi-stats');
+  
+  ombiStatus.textContent = state.ombiWebhook.enabled ? '● Enabled' : '○ Disabled';
+  ombiStatus.className = 'status-indicator ' + (state.ombiWebhook.enabled ? 'enabled' : 'disabled');
+  if (state.ombiWebhook.enabled) {
+    ombiEnableBtn.classList.add('hidden');
+    ombiTestBtn.classList.remove('hidden');
+    ombiTriggers.classList.remove('hidden');
+  } else {
+    ombiEnableBtn.classList.remove('hidden');
+    ombiTestBtn.classList.add('hidden');
+    ombiTriggers.classList.add('hidden');
+  }
+  
+  if (state.ombiWebhook.enabled) {
+    document.getElementById('ombi-requestAvailable').textContent = state.ombiWebhook.triggers.requestAvailable ? '✓' : '✗';
+    document.getElementById('ombi-requestAvailable').className = 'trigger-value ' + (state.ombiWebhook.triggers.requestAvailable ? 'active' : 'inactive');
+    document.getElementById('ombi-requestApproved').textContent = state.ombiWebhook.triggers.requestApproved ? '✓' : '✗';
+    document.getElementById('ombi-requestApproved').className = 'trigger-value ' + (state.ombiWebhook.triggers.requestApproved ? 'active' : 'inactive');
+    document.getElementById('ombi-requestDeclined').textContent = state.ombiWebhook.triggers.requestDeclined ? '✓' : '✗';
+    document.getElementById('ombi-requestDeclined').className = 'trigger-value ' + (state.ombiWebhook.triggers.requestDeclined ? 'active' : 'inactive');
+    document.getElementById('ombi-requestPending').textContent = state.ombiWebhook.triggers.requestPending ? '✓' : '✗';
+    document.getElementById('ombi-requestPending').className = 'trigger-value ' + (state.ombiWebhook.triggers.requestPending ? 'active' : 'inactive');
+    document.getElementById('ombi-requestProcessing').textContent = state.ombiWebhook.triggers.requestProcessing ? '✓' : '✗';
+    document.getElementById('ombi-requestProcessing').className = 'trigger-value ' + (state.ombiWebhook.triggers.requestProcessing ? 'active' : 'inactive');
+  }
+  
+  if (state.ombiWebhook.stats) {
+    ombiStats.classList.remove('hidden');
+    document.getElementById('ombi-events').textContent = state.ombiWebhook.stats.eventsReceived ?? 0;
+    document.getElementById('ombi-polls').textContent = state.ombiWebhook.stats.pollsSkipped ?? 0;
+    document.getElementById('ombi-last').textContent = formatTimeAgo(state.ombiWebhook.stats.lastWebhookTimestamp);
+  } else {
+    ombiStats.classList.add('hidden');
+  }
+}
+
+export async function enableSonarrWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiEnableSonarrWebhook();
+    if (!result.success) {
+      console.error('Failed to enable Sonarr webhook:', result.error);
+      alert('Failed to enable Sonarr webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to enable Sonarr webhook:', err);
+    alert('Failed to enable Sonarr webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export async function enableRadarrWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiEnableRadarrWebhook();
+    if (!result.success) {
+      console.error('Failed to enable Radarr webhook:', result.error);
+      alert('Failed to enable Radarr webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to enable Radarr webhook:', err);
+    alert('Failed to enable Radarr webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export async function testSonarrWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiTestSonarrWebhook();
+    if (result.success) {
+      alert('Sonarr webhook test sent successfully!');
+    } else {
+      console.error('Failed to test Sonarr webhook:', result.error);
+      alert('Failed to test Sonarr webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to test Sonarr webhook:', err);
+    alert('Failed to test Sonarr webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export async function testRadarrWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiTestRadarrWebhook();
+    if (result.success) {
+      alert('Radarr webhook test sent successfully!');
+    } else {
+      console.error('Failed to test Radarr webhook:', result.error);
+      alert('Failed to test Radarr webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to test Radarr webhook:', err);
+    alert('Failed to test Radarr webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export async function enableOmbiWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiEnableOmbiWebhook();
+    if (!result.success) {
+      console.error('Failed to enable Ombi webhook:', result.error);
+      alert('Failed to enable Ombi webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to enable Ombi webhook:', err);
+    alert('Failed to enable Ombi webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export async function testOmbiWebhook() {
+  setWebhookLoading(true);
+  try {
+    const result = await apiTestOmbiWebhook();
+    if (result.success) {
+      alert('Ombi webhook test sent successfully!');
+    } else {
+      console.error('Failed to test Ombi webhook:', result.error);
+      alert('Failed to test Ombi webhook. Check console for details.');
+    }
+  } catch (err) {
+    console.error('Failed to test Ombi webhook:', err);
+    alert('Failed to test Ombi webhook. Check console for details.');
+  } finally {
+    setWebhookLoading(false);
+  }
+}
+
+export function setWebhookLoading(loading) {
+  state.webhookLoading = loading;
+  document.getElementById('enable-sonarr-webhook').disabled = loading;
+  document.getElementById('enable-radarr-webhook').disabled = loading;
+  document.getElementById('enable-ombi-webhook').disabled = loading;
+  document.getElementById('test-sonarr-webhook').disabled = loading;
+  document.getElementById('test-radarr-webhook').disabled = loading;
+  document.getElementById('test-ombi-webhook').disabled = loading;
+  const loadingEl = document.getElementById('webhook-loading');
+  if (loading) {
+    loadingEl.classList.remove('hidden');
+  } else {
+    loadingEl.classList.add('hidden');
+  }
+}

client/src/utils/clientLogCapture.js

@@ -0,0 +1,137 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+const logQueue = [];
+const MAX_QUEUE_SIZE = 20;
+const FLUSH_INTERVAL_MS = 2000;
+
+// Original console functions
+const originalLog = console.log;
+const originalWarn = console.warn;
+const originalError = console.error;
+
+let isSending = false;
+let isInitialized = false;
+let flushInterval = null;
+
+function formatArgs(args) {
+  return args.map(arg => {
+    if (arg === null) return 'null';
+    if (arg === undefined) return 'undefined';
+    if (arg instanceof Error) {
+      return `${arg.name}: ${arg.message}\n${arg.stack || ''}`;
+    }
+    if (typeof arg === 'object') {
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    }
+    return String(arg);
+  }).join(' ');
+}
+
+function enqueue(level, args) {
+  const formattedMsg = formatArgs(args);
+
+  // Still write to the developer console!
+  if (level === 'info') originalLog.apply(console, args);
+  else if (level === 'warn') originalWarn.apply(console, args);
+  else if (level === 'error') originalError.apply(console, args);
+
+  // Guard against infinite loop during logs dispatching
+  if (isSending) return;
+
+  logQueue.push({
+    timestamp: new Date().toISOString(),
+    level,
+    message: formattedMsg
+  });
+
+  // Flush immediately if queue is full
+  if (logQueue.length >= MAX_QUEUE_SIZE) {
+    flushQueue();
+  }
+}
+
+async function flushQueue() {
+  if (logQueue.length === 0 || isSending) return;
+
+  isSending = true;
+  const batch = [...logQueue];
+  logQueue.length = 0;
+
+  try {
+    const response = await fetch('/api/debug/client-logs', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(batch),
+      // keepalive allows request to survive page unload
+      keepalive: true
+    });
+
+    if (!response.ok) {
+      originalError.call(console, '[clientLogCapture] Ingestion server returned error status:', response.status);
+    }
+  } catch (err) {
+    originalError.call(console, '[clientLogCapture] Ingestion post request failed:', err.message);
+  } finally {
+    isSending = false;
+  }
+}
+
+// Perform a fast/unblocked payload flush using sendBeacon on page unload
+function flushOnUnload() {
+  if (logQueue.length === 0) return;
+
+  const batch = [...logQueue];
+  logQueue.length = 0;
+
+  try {
+    const blob = new Blob([JSON.stringify(batch)], { type: 'application/json' });
+    navigator.sendBeacon('/api/debug/client-logs', blob);
+  } catch (err) {
+    // sendBeacon failure, fallback to synchronous fetch with keepalive if available
+    try {
+      fetch('/api/debug/client-logs', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(batch),
+        keepalive: true
+      });
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+export async function initClientLogCapture() {
+  if (isInitialized) return;
+
+  try {
+    // 1. Check if the server toggle for logging is active
+    const response = await fetch('/api/debug/status');
+    if (!response.ok) return;
+
+    const data = await response.json();
+    if (data && data.enabled === true) {
+      // 2. Override global console methods
+      console.log = (...args) => enqueue('info', args);
+      console.warn = (...args) => enqueue('warn', args);
+      console.error = (...args) => enqueue('error', args);
+
+      // 3. Set interval for batch updates
+      flushInterval = setInterval(flushQueue, FLUSH_INTERVAL_MS);
+
+      // 4. Setup beforeunload listener for clean flushing
+      window.addEventListener('beforeunload', flushOnUnload);
+
+      isInitialized = true;
+      console.log('[clientLogCapture] Browser console logging interceptor initialized successfully.');
+    }
+  } catch (err) {
+    originalError.call(console, '[clientLogCapture] Check failed to start interceptor:', err.message);
+  }
+}

client/src/utils/format.js

@@ -0,0 +1,74 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+export function formatSize(size) {
+  if (!size) return 'N/A';
+  // If already a formatted string (e.g., "21.5 GB"), return as-is
+  if (typeof size === 'string') {
+    return size;
+  }
+  // If it's a number (bytes), format it
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(size) / Math.log(1024));
+  return Math.round(size / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+export function formatSpeed(bytesPerSecond) {
+  if (!bytesPerSecond || bytesPerSecond === 0) return '0 B/s';
+  
+  const units = ['B/s', 'KB/s', 'MB/s', 'GB/s'];
+  let value = bytesPerSecond;
+  let unitIndex = 0;
+  
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  
+  return `${value.toFixed(2)} ${units[unitIndex]}`;
+}
+
+export function formatDate(dateString) {
+  if (!dateString) return 'N/A';
+  return new Date(dateString).toLocaleString();
+}
+
+export function formatTimeAgo(timestamp) {
+  if (!timestamp) return 'Never';
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+  if (seconds < 60) return seconds + 's ago';
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return minutes + 'm ago';
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return hours + 'h ago';
+  return Math.floor(hours / 24) + 'd ago';
+}
+
+export function escapeHtml(str) {
+  const div = document.createElement('div');
+  div.textContent = str;
+  return div.innerHTML;
+}
+
+// Build an episode-info element for series downloads/history.
+// Single episode: "S01E05 — Episode Title"
+// Multiple episodes: "Multiple episodes" with tooltip listing them all.
+// Returns null if no episode data.
+export function formatEpisodeInfo(episodes) {
+  if (!episodes || episodes.length === 0) return null;
+  const el = document.createElement('p');
+  el.className = 'episode-info';
+  if (episodes.length === 1) {
+    const ep = episodes[0];
+    const code = 'S' + String(ep.season).padStart(2, '0') + 'E' + String(ep.episode).padStart(2, '0');
+    el.textContent = ep.title ? code + ' \u2014 ' + ep.title : code;
+  } else {
+    el.textContent = 'Multiple episodes';
+    el.classList.add('multi-episode');
+    const lines = episodes.map(ep => {
+      const code = 'S' + String(ep.season).padStart(2, '0') + 'E' + String(ep.episode).padStart(2, '0');
+      return ep.title ? code + ' \u2014 ' + ep.title : code;
+    });
+    el.setAttribute('data-tooltip', lines.join('\n'));
+  }
+  return el;
+}

client/src/utils/ombiFilters.js

@@ -0,0 +1,124 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Pure filter / sort / search utilities for Ombi requests.
+ * Must stay in sync with server/utils/ombiFilters.js
+ */
+
+/**
+ * Derive a single status string from an Ombi request object.
+ * Priority: available > denied > approved > pending > unknown
+ *
+ * @param {Object} request
+ * @returns {string}
+ */
+export function getRequestStatus(request) {
+  if (!request) return 'unknown';
+  if (request.available) return 'available';
+  if (request.denied) return 'denied';
+  if (request.approved) return 'approved';
+  if (request.requested) return 'pending';
+
+  // Ombi TV requests store status flags inside childRequests
+  if (Array.isArray(request.childRequests) && request.childRequests.length > 0) {
+    for (const child of request.childRequests) {
+      if (child && child.available) return 'available';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.denied) return 'denied';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.approved) return 'approved';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.requested) return 'pending';
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Filter requests by media type.
+ *
+ * @param {Array} requests
+ * @param {string[]} types
+ * @returns {Array}
+ */
+export function filterByType(requests, types) {
+  if (!types || types.length === 0) return requests;
+  const normalized = types.map(t => t.toLowerCase());
+  if (normalized.includes('all')) return requests;
+  return requests.filter(r => normalized.includes(r.mediaType));
+}
+
+/**
+ * Filter requests by status.
+ *
+ * @param {Array} requests
+ * @param {string[]} statuses
+ * @returns {Array}
+ */
+export function filterByStatus(requests, statuses) {
+  if (!statuses || statuses.length === 0) return requests;
+  const normalized = statuses.map(s => s.toLowerCase());
+  return requests.filter(r => normalized.includes(getRequestStatus(r)));
+}
+
+/**
+ * Filter requests by case-insensitive title substring.
+ *
+ * @param {Array} requests
+ * @param {string} query
+ * @returns {Array}
+ */
+export function filterBySearch(requests, query) {
+  if (!query || query.trim() === '') return requests;
+  const q = query.trim().toLowerCase();
+  return requests.filter(r => (r.title || '').toLowerCase().includes(q));
+}
+
+/**
+ * Sort requests by the given sort mode.
+ *
+ * @param {Array} requests
+ * @param {string} sortMode
+ * @returns {Array}
+ */
+export function sortRequests(requests, sortMode) {
+  const sorted = [...requests];
+  switch (sortMode) {
+    case 'requestedDate_asc':
+      return sorted.sort((a, b) => {
+        const da = a.requestedDate ? new Date(a.requestedDate).getTime() : 0;
+        const db = b.requestedDate ? new Date(b.requestedDate).getTime() : 0;
+        return da - db;
+      });
+    case 'title_asc':
+      return sorted.sort((a, b) => (a.title || '').localeCompare(b.title || ''));
+    case 'title_desc':
+      return sorted.sort((a, b) => (b.title || '').localeCompare(a.title || ''));
+    case 'requestedDate_desc':
+    default:
+      return sorted.sort((a, b) => {
+        const da = a.requestedDate ? new Date(a.requestedDate).getTime() : 0;
+        const db = b.requestedDate ? new Date(b.requestedDate).getTime() : 0;
+        return db - da;
+      });
+  }
+}
+
+/**
+ * Apply all filters and sorting in one call.
+ *
+ * @param {Array} requests
+ * @param {Object} options
+ * @returns {Array}
+ */
+export function applyRequestFilters(requests, { types, statuses, sort, search } = {}) {
+  let result = [...requests];
+  result = filterByType(result, types);
+  result = filterByStatus(result, statuses);
+  result = filterBySearch(result, search);
+  result = sortRequests(result, sort);
+  return result;
+}

client/src/utils/storage.js

@@ -0,0 +1,127 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+import { state } from '../state.js';
+
+// Migration from old single-select to new multi-select format
+(function migrateDownloadClientFilter() {
+  const oldSelection = localStorage.getItem('sofarr-download-client');
+  if (oldSelection && oldSelection !== 'all') {
+    try {
+      state.selectedDownloadClients = [oldSelection];
+      localStorage.setItem('sofarr-download-clients', JSON.stringify(state.selectedDownloadClients));
+      localStorage.removeItem('sofarr-download-client');
+    } catch (e) {
+      console.error('[Migration] Failed to migrate download client filter:', e);
+    }
+  } else {
+    try {
+      const newSelection = localStorage.getItem('sofarr-download-clients');
+      state.selectedDownloadClients = newSelection ? JSON.parse(newSelection) : [];
+    } catch (e) {
+      console.error('[Migration] Failed to load download client filter:', e);
+      state.selectedDownloadClients = [];
+    }
+  }
+})();
+
+// Load history days from localStorage
+(function loadHistorySettings() {
+  try {
+    const savedDays = localStorage.getItem('sofarr-history-days');
+    if (savedDays) {
+      state.historyDays = parseInt(savedDays, 10) || 7;
+    }
+  } catch (e) {
+    console.error('[Storage] Failed to load history days:', e);
+  }
+})();
+
+// Load ignore available setting from localStorage
+(function loadIgnoreAvailable() {
+  try {
+    const saved = localStorage.getItem('sofarr-ignore-available');
+    state.ignoreAvailable = saved === 'true';
+  } catch (e) {
+    console.error('[Storage] Failed to load ignore available:', e);
+  }
+})();
+
+// Load request filter preferences from localStorage
+(function loadRequestFilters() {
+  try {
+    const savedTypes = localStorage.getItem('sofarr-request-types');
+    if (savedTypes) state.selectedRequestTypes = JSON.parse(savedTypes);
+  } catch (e) {
+    console.error('[Storage] Failed to load request types:', e);
+    state.selectedRequestTypes = ['movie', 'tv'];
+  }
+
+  try {
+    const savedStatuses = localStorage.getItem('sofarr-request-statuses');
+    if (savedStatuses) state.selectedRequestStatuses = JSON.parse(savedStatuses);
+  } catch (e) {
+    console.error('[Storage] Failed to load request statuses:', e);
+    state.selectedRequestStatuses = [];
+  }
+
+  try {
+    const savedSort = localStorage.getItem('sofarr-request-sort');
+    if (savedSort) state.requestSortMode = savedSort;
+  } catch (e) {
+    console.error('[Storage] Failed to load request sort:', e);
+    state.requestSortMode = 'requestedDate_desc';
+  }
+
+  try {
+    const savedSearch = localStorage.getItem('sofarr-request-search');
+    if (savedSearch !== null) state.requestSearchQuery = savedSearch;
+  } catch (e) {
+    console.error('[Storage] Failed to load request search:', e);
+    state.requestSearchQuery = '';
+  }
+})();
+
+// Export helper functions for localStorage operations
+export function saveHistoryDays(days) {
+  localStorage.setItem('sofarr-history-days', days);
+}
+
+export function saveIgnoreAvailable(value) {
+  localStorage.setItem('sofarr-ignore-available', value);
+}
+
+export function saveDownloadClients(clients) {
+  localStorage.setItem('sofarr-download-clients', JSON.stringify(clients));
+}
+
+export function getTheme() {
+  return localStorage.getItem('sofarr-theme') || 'light';
+}
+
+export function saveTheme(theme) {
+  localStorage.setItem('sofarr-theme', theme);
+}
+
+export function getActiveTab() {
+  return localStorage.getItem('sofarr-active-tab') || 'downloads';
+}
+
+export function saveActiveTab(tab) {
+  localStorage.setItem('sofarr-active-tab', tab);
+}
+
+export function saveRequestTypes(types) {
+  localStorage.setItem('sofarr-request-types', JSON.stringify(types));
+}
+
+export function saveRequestStatuses(statuses) {
+  localStorage.setItem('sofarr-request-statuses', JSON.stringify(statuses));
+}
+
+export function saveRequestSort(sort) {
+  localStorage.setItem('sofarr-request-sort', sort);
+}
+
+export function saveRequestSearch(query) {
+  localStorage.setItem('sofarr-request-search', query);
+}

client/vite.config.js

@@ -1,16 +1,50 @@
 // Copyright (c) 2026 Gordon Bolton. MIT License.
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
+import { defineConfig, loadEnv } from 'vite'
+import path from 'path'
 
-export default defineConfig({
-  plugins: [react()],
-  server: {
-    port: 5173,
-    proxy: {
-      '/api': {
-        target: 'http://localhost:3001',
-        changeOrigin: true
+export default defineConfig(({ mode }) => {
+  // Load env variables from root directory to match backend TLS configuration
+  const env = loadEnv(mode, path.resolve(__dirname, '..'), '');
+
+  const port = env.PORT || 3001;
+  const tlsEnabled = (env.TLS_ENABLED || 'true').toLowerCase() !== 'false';
+  const target = `${tlsEnabled ? 'https' : 'http'}://localhost:${port}`;
+
+  return {
+    build: {
+      // NOTE (Issue #66): `outDir` is intentionally the repo-root `../public`,
+      // NOT the Vite default `client/dist/`. The Express server in
+      // `server/app.js` serves static assets directly from `public/`, so the
+      // Vite build emits its bundle alongside the hand-authored static assets
+      // (favicon, etc.) that live in `public/` and are committed to the repo.
+      // Do NOT change this back to `dist/` without also updating the Express
+      // static-serve configuration and the Dockerfile copy steps.
+      outDir: '../public',
+      // NOTE (Issue #66): `emptyOutDir: false` is REQUIRED because `public/`
+      // contains hand-authored static assets that must survive the build.
+      // Setting this to `true` would wipe those assets on every `vite build`.
+      emptyOutDir: false,
+      rollupOptions: {
+        input: {
+          main: './src/main.js'
+        },
+        output: {
+          entryFileNames: 'app.js',
+          chunkFileNames: '[name].js',
+          assetFileNames: '[name][extname]'
+        }
+      }
+    },
+    server: {
+      port: 5173,
+      host: true, // Listen on all network interfaces
+      proxy: {
+        '/api': {
+          target: target,
+          changeOrigin: true,
+          secure: false // Allow self-signed certificate in development
+        }
       }
     }
-  }
-})
+  };
+});

docker-compose.yaml

@@ -44,13 +44,17 @@ services:
     volumes:
       # Persistent volume for token store and log file
       - sofarr-data:/app/data
+      # Mount code for development (comment out in production)
+      - ./server:/app/server
+      - ./public:/app/public
       # Mount your own TLS certificate and key (optional — snakeoil used if omitted)
       # - /path/to/your/server.crt:/app/certs/server.crt:ro
       # - /path/to/your/server.key:/app/certs/server.key:ro
     # Run as the built-in non-root 'node' user (UID/GID 1000)
     user: "1000:1000"
     # Read-only root filesystem; only the data volume is writable
-    read_only: true
+    # Comment out for development when mounting code volumes
+    # read_only: true
     tmpfs:
       - /tmp                    # Node.js needs a writable /tmp
     security_opt:

package.json

@@ -1,11 +1,14 @@
 {
   "name": "sofarr",
-  "version": "1.5.3",
+  "version": "1.7.35",
   "description": "A personal media download dashboard that shows your downloads 'so far' while you relax on the sofa waiting for your *arr services to finish",
   "main": "server/index.js",
   "scripts": {
-    "dev": "nodemon server/index.js",
+    "dev:server": "nodemon server/index.js",
+    "dev:client": "npm run dev --prefix client",
+    "dev": "concurrently -n 'server,client' -c 'blue,green' 'npm run dev:server' 'npm run dev:client'",
     "start": "node server/index.js",
+    "build": "npm run build --prefix client",
     "install:all": "npm install",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -13,7 +16,10 @@
     "test:ui": "vitest --ui",
     "audit": "npm audit --audit-level=high",
     "audit:fix": "npm audit fix",
-    "audit:critical": "npm audit --audit-level=critical"
+    "audit:critical": "npm audit --audit-level=critical",
+    "generate:openapi": "node scripts/generate-openapi.js",
+    "generate:raml": "node scripts/downgrade-openapi.js && node scripts/simple-raml-converter.js",
+    "package:raml": "node scripts/package-raml.js"
   },
   "dependencies": {
     "axios": "^1.6.0",
@@ -23,10 +29,15 @@
     "express-rate-limit": "^7.0.0",
     "helmet": "^7.0.0",
     "jsdom": "^29.1.1",
-    "xmlrpc": "^1.3.2"
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1",
+    "xmlrpc": "^1.3.2",
+    "yamljs": "^0.3.0"
   },
   "devDependencies": {
+    "@stoplight/spectral-cli": "^6.16.0",
     "@vitest/coverage-v8": "^4.1.6",
+    "archiver": "^7.0.1",
     "concurrently": "^7.6.0",
     "nock": "^14.0.15",
     "nodemon": "^3.1.14",

public/images/clients/deluge.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" viewBox="0 0 512 512"><path d="m256.1 2.6 142 217.2c91 139.2-4.7 289.6-142.1 289.6S22.8 358.9 113.9 219.8z" style="fill-rule:evenodd;clip-rule:evenodd;fill:#4c90e8;stroke:#094491;stroke-width:3.1904"/><path d="M306.7 255.2c-77.6-31.7-118.4 49.2-105.4 87C229.5 424.4 335.8 445 414.2 308c0 0 .8 16.5 1.7 24.4 10.5 99.9-73.5 163.4-158.6 162.2s-111.1-34.3-136.2-72.3C80.4 360.6 90.5 260 145.2 212.9c62.5-51.6 131.2-24 161.5 42.3" style="fill-rule:evenodd;clip-rule:evenodd;fill:#094491"/><path d="M257.9 225.3c-87 2.1-103.5 102.3-79.4 145.3 33.5 59.7 84.3 71.2 153.8 49.1-39.7 43.2-121.2 54.6-176.5-7.1-38.1-42.4-41.4-101.6-15-151.1 26.5-49.4 79.2-63.2 117.1-36.2" style="fill-rule:evenodd;clip-rule:evenodd;fill:#83b8f9"/></svg>

public/images/clients/orphaned.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="100%" height="100%">
+  <circle cx="256" cy="256" r="240" fill="#f5f5f7" stroke="#d2d2d7" stroke-width="20"/>
+  <text x="50%" y="60%" font-family="system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif" font-size="300px" font-weight="bold" fill="#86868b" text-anchor="middle" dominant-baseline="middle">?</text>
+</svg>

public/images/clients/qbittorrent.svg

@@ -0,0 +1 @@
+<svg height="1024" viewBox="0 0 1024 1024" width="1024" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><linearGradient id="a" gradientUnits="userSpaceOnUse" x1="348.2829" x2="782.05951" y1="0" y2="786.48322"><stop offset="0" stop-color="#72b4f5"/><stop offset="1" stop-color="#356ebf"/></linearGradient><g fill="none" fill-rule="evenodd" transform="matrix(.97656268 0 0 .9765624 11.999908 12.000051)"><circle cx="512" cy="512" fill="url(#a)" r="496" stroke="#daefff" stroke-width="32"/><path d="m712.898 332.399q66.657 0 103.38 45.671 37.03 45.364 37.03 128.684 0 83.32-37.34 129.61-37.03 45.98-103.07 45.98-33.02 0-60.484-12.035-27.156-12.344-45.672-37.649h-3.703l-10.8 43.512h-36.724v-480.172h51.227v116.65q0 39.191-2.469 70.359h2.47q35.796-50.61 106.155-50.61zm-7.406 42.894q-52.46 0-75.605 30.242-23.145 29.934-23.145 101.219 0 71.285 23.762 102.145 23.761 30.55 76.222 30.55 47.215 0 70.36-34.254 23.144-34.562 23.144-99.058 0-66.04-23.144-98.442-23.145-32.402-71.594-32.402z" fill="#fff"/><path d="m317.273 639.45q51.227 0 74.68-27.466 23.453-27.464 24.996-92.578v-11.418q0-70.976-24.07-102.144-24.07-31.168-76.223-31.168-45.055 0-69.125 35.18-23.762 34.87-23.762 98.75 0 63.879 23.454 97.515 23.761 33.328 70.05 33.328zm-7.715 42.894q-65.421 0-102.144-45.98-36.723-45.981-36.723-128.376 0-83.011 37.032-129.609 37.03-46.598 103.07-46.598 69.433 0 106.773 52.461h2.778l7.406-46.289h40.426v490.047h-51.227v-144.73q0-30.86 3.395-52.461h-4.012q-35.488 51.535-106.774 51.535z" fill="#c8e8ff"/></g></svg>

public/images/clients/sabnzbd.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000"><path fill="#f5f5f5000" stroke="#f5f5f5" stroke-linejoin="round" stroke-width="74" d="M200.4 39.3h598.1v437.8h161l-460.1 483L39.4 477h161z"/><path fill="#ffb300" fill-rule="evenodd" d="M200.4 39.3h598.1v437.8h161l-460.1 483-460-483h161z"/><path fill="#ffca28" fill-rule="evenodd" d="M499.4 960.2 201.1 39.4h596.7z"/><path fill="#f5f5f5000" stroke="#f5f5f5" stroke-linecap="round" stroke-linejoin="round" stroke-width="74" d="M329.2 843.5H83v-51.8h146.1v-45.9H83V596.9h246.2v51.5H183.1v45.9h146.1zm292.2 0H375.2V694.3h146.1v-45.9H375.2v-51.5h246.2zm-146.1-97.8h46v46h-46zm192.1 97.8v-344h100.1v97.4h146.1v246.6zm100.1-195.2h46v143.4h-46z"/><path fill="#0f0f0f" fill-rule="evenodd" d="M329.2 843.5H83v-51.8h146.1v-45.9H83V596.9h246.2v51.5H183.1v45.9h146.1zm292.2 0H375.2V694.3h146.1v-45.9H375.2v-51.5h246.2zm-146.1-51.8h46v-46h-46zm192.1 51.9v-344h100.1V597h146.1v246.6zm100.1-51.9h46V648.4h-46z"/></svg>

public/images/radarr.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" id="Layer_1" x="0" y="0" version="1.1" viewBox="0 0 512 512"><style>.st0{fill:#24292e}</style><g id="Group-Copy" transform="translate(70 21)"><path id="Shape" d="m10.3 59.8 3.9 372.4c-31.4 3.9-54.9-11.8-54.9-43.1l-3.9-309.7c0-98 90.2-121.5 145.1-82.3l278.3 160.7c39.2 27.4 47 78.4 27.4 113.7-3.9-27.4-15.7-43.1-39.2-58.8L53.4 36.2C29.9 20.6 10.3 24.5 10.3 59.8" class="st0"/><path id="Shape_00000114049535938561773820000018271523940913105341_" d="M-13.2 451.8c23.5 7.8 47 3.9 66.6-7.8l321.5-188.2c19.6 27.4 15.7 54.9-7.8 70.6L96.5 483.2c-39.2 19.6-90.1 0-109.7-31.4" class="st0"/><path id="Shape_00000165935924413286433040000003668002807793862576_" d="M80.9 342 273 232.3 84.8 126.4z" style="fill:#ffc230"/></g></svg>

public/images/sonarr.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" viewBox="0 0 512 512"><path d="M511.8 256c0 70.4-24.9 130.8-74.6 181.1-1.7 2-3.5 3.8-5.5 5.4-8.2 8-16.8 15.3-26 21.8Q341.05 512 256.3 512c-56.6 0-106.3-15.9-149.2-47.7-11.3-8-22-17.1-31.9-27.3C36.5 398.7 12.8 354 4 303.2c-1.7-9.9-2.9-20-3.4-30.2-.2-5.7-.4-11.3-.4-17 0-6 .1-11.7.4-17.1 0-.6.2-1.1.5-1.7 3.7-62.8 28.4-117 74.1-162.8C125.5 24.8 185.8 0 256.2 0c70.7 0 131 24.8 180.9 74.5q74.7 75.9 74.7 181.5" style="fill-rule:evenodd;clip-rule:evenodd;fill:#eee"/><path d="m459.7 100.3-52.9 52.9c-30.9 30.9-33.6 57.8-33.6 105.3 0 42.3 6.7 81.1 38.2 112.6 23 23 44.9 44.7 44.9 44.7-5.9 7.2-12.3 14.3-19.1 21.2-1.7 2-3.5 3.8-5.5 5.4-6 5.9-12.2 11.4-18.6 16.4l-41.4-41.4C334.9 380.6 305.6 377 257 377c-46.7 0-78.4 4.3-112.6 38.5-20.4 20.4-43.8 43.9-43.8 43.9-8.9-6.8-17.3-14.2-25.3-22.4-6.6-6.6-12.8-13.4-18.5-20.3 0 0 23.1-23.2 45.2-45.3 32.7-32.7 38-70.6 38-113 0-41.3-6.8-79.8-36.8-109.9C82.2 127.7 53.3 99 53.3 99c6.7-8.5 14-16.7 21.8-24.5 6.9-6.8 14-13.1 21.2-19l48 48c30.7 30.7 70 38.6 112.4 38.6 43.6 0 82.8-8.4 114.7-40.4C391 82.1 417 56.3 417 56.3c6.8 5.6 13.5 11.6 20.1 18.2 8.3 8.3 15.8 16.9 22.6 25.8" style="fill-rule:evenodd;clip-rule:evenodd;fill:#3a3f51"/><path d="M186 269.1c-.5-2.8-.8-5.5-.9-8.4-.1-1.6-.1-3.1-.1-4.7 0-1.7 0-3.2.1-4.7 0-.2 0-.3.1-.5 1-17.4 7.9-32.4 20.5-45.1 13.9-13.8 30.6-20.7 50.2-20.7s36.3 6.9 50.2 20.7c13.8 14 20.7 30.8 20.7 50.3s-6.9 36.2-20.7 50.2c-.5.5-1 1.1-1.5 1.5q-3.45 3.3-7.2 6-18 13.2-41.4 13.2c-23.4 0-29.4-4.4-41.3-13.2-3.1-2.2-6.1-4.7-8.9-7.6-10.8-10.6-17.3-22.9-19.8-37" style="fill-rule:evenodd;clip-rule:evenodd;fill:#0cf"/><path d="m372.7 141-35.4 34.6M72.9 76.8l96.5 96.1m199.7 198.9 65.6 67.9m4.4-363.3L372.7 141M76.6 438.5l64.6-64.7" style="fill:none;stroke:#0cf;stroke-width:2;stroke-miterlimit:1"/><path d="m372.7 141-40 40.6m-193.3-38.5 40.6 40.5M141 374l39.5-41.1m146.2-3.3 42.6 42.4" style="fill:none;stroke:#0cf;stroke-width:7;stroke-miterlimit:1"/></svg>

public/index.html

@@ -18,7 +18,7 @@
 
     <div class="app">
         <!-- Login Form -->
-        <div id="login-container" class="login-container" style="display: none;">
+        <div id="login-container" class="login-container hidden">
             <div class="login-box">
                 <img src="images/sofarr-flashscreen.png" alt="sofarr" class="login-logo">
                 <p class="login-subtitle">Login with your Emby credentials</p>
@@ -39,12 +39,12 @@
                     </div>
                     <button type="submit" class="login-btn">Login</button>
                 </form>
-                <div id="login-error" class="error-message" style="display: none;"></div>
+                <div id="login-error" class="error-message hidden"></div>
             </div>
         </div>
 
         <!-- Dashboard -->
-        <div id="dashboard-container" class="dashboard-container" style="display: none;">
+        <div id="dashboard-container" class="dashboard-container hidden">
             <header class="app-header">
                 <h1><a href="#" class="title-link" id="title-home-link"><img src="favicon-192.png" alt="" class="title-logo">sofarr</a></h1>
                 <div class="header-controls">
@@ -53,7 +53,7 @@
                         <button class="theme-btn" data-theme="dark">Dark</button>
                         <button class="theme-btn" data-theme="mono">Mono</button>
                     </div>
-                    <div id="admin-controls" class="admin-controls" style="display: none;">
+                    <div id="admin-controls" class="admin-controls hidden">
                         <label class="toggle-label">
                             <input type="checkbox" id="show-all-toggle">
                             <span>Show all users</span>
@@ -68,35 +68,35 @@
                 </div>
             </header>
 
-            <div id="status-panel" class="status-panel" style="display: none;">
+            <div id="status-panel" class="status-panel hidden">
                 <!-- Status content gets rendered here -->
                 <div id="status-content"><p class="status-loading">Loading status...</p></div>
             </div>
 
             <!-- Webhooks Configuration Panel (sibling to status-panel) -->
-            <div class="webhooks-section" id="webhooks-section" style="display: none;">
+            <div class="webhooks-section hidden" id="webhooks-section">
                 <div class="webhooks-header" id="webhooks-header">
                     <h2>⚡ Webhooks Configuration</h2>
                     <span class="webhooks-toggle" id="webhooks-toggle">▼</span>
                 </div>
-                <div class="webhooks-content" id="webhooks-content" style="display: none;">
-                    <div id="webhook-loading" class="webhook-loading" style="display: none;">Loading webhook status...</div>
+                <div class="webhooks-content hidden" id="webhooks-content">
+                    <div id="webhook-loading" class="webhook-loading hidden">Loading webhook status...</div>
 
                     <!-- Sonarr Webhook -->
                     <div class="webhook-instance">
                         <h3>Sonarr</h3>
                         <div class="webhook-status">
                             <span class="status-indicator" id="sonarr-status">○ Disabled</span>
-                            <button id="enable-sonarr-webhook" class="enable-webhook-btn" style="display: none;">Enable Sofarr Webhooks</button>
-                            <button id="test-sonarr-webhook" class="test-webhook-btn" style="display: none;">Test</button>
+                            <button id="enable-sonarr-webhook" class="enable-webhook-btn hidden">Enable Sofarr Webhooks</button>
+                            <button id="test-sonarr-webhook" class="test-webhook-btn hidden">Test</button>
                         </div>
-                        <div class="webhook-triggers" id="sonarr-triggers" style="display: none;">
+                        <div class="webhook-triggers hidden" id="sonarr-triggers">
                             <div class="trigger-item"><span class="trigger-label">On Grab</span><span class="trigger-value" id="sonarr-onGrab">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Download</span><span class="trigger-value" id="sonarr-onDownload">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Import</span><span class="trigger-value" id="sonarr-onImport">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Upgrade</span><span class="trigger-value" id="sonarr-onUpgrade">✗</span></div>
                         </div>
-                        <div class="webhook-stats" id="sonarr-stats" style="display: none;">
+                        <div class="webhook-stats hidden" id="sonarr-stats">
                             <div class="webhook-stats-title">Statistics</div>
                             <div class="webhook-stats-grid">
                                 <div class="webhook-stat"><span class="webhook-stat-label">Events Received</span><span class="webhook-stat-value" id="sonarr-events">0</span></div>
@@ -111,16 +111,16 @@
                         <h3>Radarr</h3>
                         <div class="webhook-status">
                             <span class="status-indicator" id="radarr-status">○ Disabled</span>
-                            <button id="enable-radarr-webhook" class="enable-webhook-btn" style="display: none;">Enable Sofarr Webhooks</button>
-                            <button id="test-radarr-webhook" class="test-webhook-btn" style="display: none;">Test</button>
+                            <button id="enable-radarr-webhook" class="enable-webhook-btn hidden">Enable Sofarr Webhooks</button>
+                            <button id="test-radarr-webhook" class="test-webhook-btn hidden">Test</button>
                         </div>
-                        <div class="webhook-triggers" id="radarr-triggers" style="display: none;">
+                        <div class="webhook-triggers hidden" id="radarr-triggers">
                             <div class="trigger-item"><span class="trigger-label">On Grab</span><span class="trigger-value" id="radarr-onGrab">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Download</span><span class="trigger-value" id="radarr-onDownload">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Import</span><span class="trigger-value" id="radarr-onImport">✗</span></div>
                             <div class="trigger-item"><span class="trigger-label">On Upgrade</span><span class="trigger-value" id="radarr-onUpgrade">✗</span></div>
                         </div>
-                        <div class="webhook-stats" id="radarr-stats" style="display: none;">
+                        <div class="webhook-stats hidden" id="radarr-stats">
                             <div class="webhook-stats-title">Statistics</div>
                             <div class="webhook-stats-grid">
                                 <div class="webhook-stat"><span class="webhook-stat-label">Events Received</span><span class="webhook-stat-value" id="radarr-events">0</span></div>
@@ -129,22 +129,72 @@
                             </div>
                         </div>
                     </div>
+
+                    <!-- Ombi Webhook -->
+                    <div class="webhook-instance">
+                        <h3>Ombi</h3>
+                        <div class="webhook-status">
+                            <span class="status-indicator" id="ombi-status">○ Disabled</span>
+                            <button id="enable-ombi-webhook" class="enable-webhook-btn hidden">Enable Sofarr Webhooks</button>
+                            <button id="test-ombi-webhook" class="test-webhook-btn hidden">Test</button>
+                        </div>
+                        <div class="webhook-triggers hidden" id="ombi-triggers">
+                            <div class="trigger-item"><span class="trigger-label">Request Available</span><span class="trigger-value" id="ombi-requestAvailable">✗</span></div>
+                            <div class="trigger-item"><span class="trigger-label">Request Approved</span><span class="trigger-value" id="ombi-requestApproved">✗</span></div>
+                            <div class="trigger-item"><span class="trigger-label">Request Declined</span><span class="trigger-value" id="ombi-requestDeclined">✗</span></div>
+                            <div class="trigger-item"><span class="trigger-label">Request Pending</span><span class="trigger-value" id="ombi-requestPending">✗</span></div>
+                            <div class="trigger-item"><span class="trigger-label">Request Processing</span><span class="trigger-value" id="ombi-requestProcessing">✗</span></div>
+                        </div>
+                        <div class="webhook-stats hidden" id="ombi-stats">
+                            <div class="webhook-stats-title">Statistics</div>
+                            <div class="webhook-stats-grid">
+                                <div class="webhook-stat"><span class="webhook-stat-label">Events Received</span><span class="webhook-stat-value" id="ombi-events">0</span></div>
+                                <div class="webhook-stat"><span class="webhook-stat-label">Polls Skipped</span><span class="webhook-stat-value" id="ombi-polls">0</span></div>
+                                <div class="webhook-stat"><span class="webhook-stat-label">Last Event</span><span class="webhook-stat-value" id="ombi-last">Never</span></div>
+                            </div>
+                        </div>
+                    </div>
                 </div>
             </div>
 
-            <div id="error-message" class="error-message" style="display: none;"></div>
+            <div id="error-message" class="error-message hidden"></div>
 
-            <div id="loading" class="loading" style="display: none;">Loading downloads...</div>
+            <div id="loading" class="loading hidden">Loading downloads...</div>
 
             <div class="main-tabs">
                 <div class="tab-bar">
                     <button class="tab-btn active" data-tab="downloads">Active Downloads</button>
+                    <button class="tab-btn" data-tab="requests">Requests</button>
                     <button class="tab-btn" data-tab="history">Recently Completed</button>
                 </div>
 
                 <div class="tab-panel" id="tab-downloads">
                     <div class="downloads-container">
-                        <div id="no-downloads" class="no-downloads" style="display: none;">
+                        <div class="downloads-header tab-header">
+                            <div class="tab-header-title">
+                                <h2><span class="tab-header-icon">📥</span> Active Downloads</h2>
+                                <p class="tab-header-subtitle">Track and manage your active media downloads in real-time</p>
+                            </div>
+                            <div class="downloads-controls tab-header-controls">
+                                <label class="download-client-label" for="download-client-filter">Download client:</label>
+                                <div class="download-client-filter" id="download-client-filter">
+                                    <button class="download-client-dropdown-btn" id="download-client-dropdown-btn" type="button" aria-expanded="false">
+                                        <span id="download-client-selected-text">All clients</span>
+                                        <span class="dropdown-arrow">▼</span>
+                                    </button>
+                                    <div class="download-client-dropdown" id="download-client-dropdown">
+                                        <div class="download-client-dropdown-header">
+                                            <button class="download-client-dropdown-btn-small" id="download-client-select-all" type="button">Select All</button>
+                                            <button class="download-client-dropdown-btn-small" id="download-client-deselect-all" type="button">Deselect All</button>
+                                        </div>
+                                        <div class="download-client-options" id="download-client-options">
+                                            <!-- Options will be populated by JavaScript -->
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        <div id="no-downloads" class="no-downloads hidden">
                             <p>No downloads found for your user.</p>
                             <p>Make sure your shows and movies are tagged with your username in Sonarr/Radarr.</p>
                         </div>
@@ -152,10 +202,104 @@
                     </div>
                 </div>
 
-                <div class="tab-panel" id="tab-history" style="display: none;">
+                <div class="tab-panel hidden" id="tab-requests">
+                    <div class="requests-container">
+                        <div class="requests-header tab-header">
+                            <div class="tab-header-title">
+                                <h2><span class="tab-header-icon">📨</span> Requests</h2>
+                                <p class="tab-header-subtitle">Browse, filter, and track requests synced from Ombi</p>
+                            </div>
+                            <div class="requests-controls tab-header-controls">
+                                <!-- Media Type Filter -->
+                                <div class="request-filter" id="request-type-filter">
+                                    <label class="request-filter-label">Type:</label>
+                                    <button class="request-filter-btn" id="request-type-filter-btn" type="button" aria-expanded="false">
+                                        <span id="request-type-selected-text">All</span>
+                                        <span class="dropdown-arrow">▼</span>
+                                    </button>
+                                    <div class="request-filter-dropdown" id="request-type-filter-dropdown">
+                                        <div class="request-filter-dropdown-header">
+                                            <button class="request-filter-dropdown-btn-small" id="request-type-select-all" type="button">Select All</button>
+                                            <button class="request-filter-dropdown-btn-small" id="request-type-deselect-all" type="button">Deselect All</button>
+                                        </div>
+                                        <div class="request-filter-options" id="request-type-options">
+                                            <div class="request-filter-option" data-value="movie">
+                                                <input type="checkbox" id="request-type-movie" class="request-filter-checkbox" checked>
+                                                <label for="request-type-movie">Movies</label>
+                                            </div>
+                                            <div class="request-filter-option" data-value="tv">
+                                                <input type="checkbox" id="request-type-tv" class="request-filter-checkbox" checked>
+                                                <label for="request-type-tv">TV Shows</label>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <!-- Status Filter -->
+                                <div class="request-filter" id="request-status-filter">
+                                    <label class="request-filter-label">Status:</label>
+                                    <button class="request-filter-btn" id="request-status-filter-btn" type="button" aria-expanded="false">
+                                        <span id="request-status-selected-text">All</span>
+                                        <span class="dropdown-arrow">▼</span>
+                                    </button>
+                                    <div class="request-filter-dropdown" id="request-status-filter-dropdown">
+                                        <div class="request-filter-dropdown-header">
+                                            <button class="request-filter-dropdown-btn-small" id="request-status-select-all" type="button">Select All</button>
+                                            <button class="request-filter-dropdown-btn-small" id="request-status-deselect-all" type="button">Deselect All</button>
+                                        </div>
+                                        <div class="request-filter-options" id="request-status-options">
+                                            <div class="request-filter-option" data-value="pending">
+                                                <input type="checkbox" id="request-status-pending" class="request-filter-checkbox">
+                                                <label for="request-status-pending">Pending</label>
+                                            </div>
+                                            <div class="request-filter-option" data-value="approved">
+                                                <input type="checkbox" id="request-status-approved" class="request-filter-checkbox">
+                                                <label for="request-status-approved">Approved</label>
+                                            </div>
+                                            <div class="request-filter-option" data-value="available">
+                                                <input type="checkbox" id="request-status-available" class="request-filter-checkbox">
+                                                <label for="request-status-available">Available</label>
+                                            </div>
+                                            <div class="request-filter-option" data-value="denied">
+                                                <input type="checkbox" id="request-status-denied" class="request-filter-checkbox">
+                                                <label for="request-status-denied">Denied</label>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <!-- Sort Dropdown -->
+                                <div class="request-sort">
+                                    <label class="request-filter-label" for="request-sort-select">Sort:</label>
+                                    <select id="request-sort-select" class="request-sort-select">
+                                        <option value="requestedDate_desc">Newest to oldest</option>
+                                        <option value="requestedDate_asc">Oldest to newest</option>
+                                        <option value="title_asc">A–Z</option>
+                                        <option value="title_desc">Z–A</option>
+                                    </select>
+                                </div>
+
+                                <!-- Search Input -->
+                                <div class="request-search">
+                                    <input type="text" id="request-search-input" class="request-search-input" placeholder="Search by title...">
+                                </div>
+                            </div>
+                        </div>
+                        <div id="no-requests" class="no-requests hidden">
+                            <p>No requests found.</p>
+                        </div>
+                        <div id="requests-list" class="requests-list"></div>
+                    </div>
+                </div>
+
+                <div class="tab-panel hidden" id="tab-history">
                     <div class="history-container" id="history-container">
-                        <div class="history-header">
-                            <div class="history-controls">
+                        <div class="history-header tab-header">
+                            <div class="tab-header-title">
+                                <h2><span class="tab-header-icon">📜</span> Recently Completed</h2>
+                                <p class="tab-header-subtitle">Review successful imports and troubleshoot failed upgrade attempts</p>
+                            </div>
+                            <div class="history-controls tab-header-controls">
                                 <label class="history-days-label" for="history-days">Last</label>
                                 <input type="number" id="history-days" class="history-days-input" value="7" min="1" max="90">
                                 <span class="history-days-label">days</span>
@@ -166,9 +310,9 @@
                                 </label>
                             </div>
                         </div>
-                        <div id="history-loading" class="history-loading" style="display: none;">Loading history...</div>
-                        <div id="history-error" class="history-error" style="display: none;"></div>
-                        <div id="no-history" class="no-history" style="display: none;">
+                        <div id="history-loading" class="history-loading hidden">Loading history...</div>
+                        <div id="history-error" class="history-error hidden"></div>
+                        <div id="no-history" class="no-history hidden">
                             <p>No completed downloads found in this period.</p>
                         </div>
                         <div id="history-list" class="history-list"></div>

public/style.css

@@ -1,3 +1,29 @@
+/* ===== Utility Classes ===== */
+.hidden {
+  display: none !important;
+}
+
+/* ===== Service Icons ===== */
+.service-icons-container {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  margin-right: 6px;
+}
+
+.service-icon {
+  height: 1.2em; /* Match text height */
+  width: auto;
+  vertical-align: middle;
+  cursor: pointer;
+  opacity: 0.8;
+  transition: opacity 0.2s ease;
+}
+
+.service-icon:hover {
+  opacity: 1;
+}
+
 /* ===== Splash Screen ===== */
 .splash-screen {
   position: fixed;
@@ -373,6 +399,7 @@ body {
   align-items: flex-start;
   transition: box-shadow 0.2s, background 0.3s;
   background: var(--surface);
+  position: relative;
 }
 
 .download-card:hover {
@@ -662,19 +689,436 @@ body {
   padding: 0;
 }
 
-.history-header {
+/* Unified Tab Headers (Issue #72) */
+.tab-header {
   display: flex;
+  justify-content: space-between;
   align-items: center;
-  gap: 12px;
-  margin-bottom: 12px;
+  gap: 16px;
+  margin-bottom: 20px;
+  padding-bottom: 16px;
+  border-bottom: 1px solid var(--border);
   flex-wrap: wrap;
 }
 
-.history-header h2 {
+.tab-header-title {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.tab-header-title h2 {
   margin: 0;
-  font-size: 1.2rem;
+  font-size: 1.25rem;
+  font-weight: 600;
   color: var(--text-primary);
-  flex: 1 1 auto;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.tab-header-icon {
+  font-size: 1.3rem;
+  display: inline-flex;
+  align-items: center;
+}
+
+.tab-header-subtitle {
+  margin: 0;
+  font-size: 0.8rem;
+  color: var(--text-muted);
+}
+
+.tab-header-controls {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.tab-header, .tab-header-title h2, .tab-header-subtitle {
+  transition: color 0.3s, border-color 0.3s;
+}
+
+.downloads-header {
+  /* Inherits from .tab-header */
+}
+
+.downloads-controls {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: nowrap;
+}
+
+.download-client-label {
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+}
+
+.download-client-select {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+  cursor: pointer;
+}
+
+.download-client-select:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+/* Multi-select dropdown container */
+.download-client-filter {
+  position: relative;
+  display: inline-block;
+}
+
+.download-client-dropdown-btn {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+  cursor: pointer;
+  min-width: 140px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  transition: background 0.15s, border-color 0.15s;
+}
+
+.download-client-dropdown-btn:hover {
+  background: var(--hover-bg);
+}
+
+.download-client-dropdown-btn:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.download-client-dropdown-btn .dropdown-arrow {
+  font-size: 0.75rem;
+  transition: transform 0.2s;
+}
+
+.download-client-dropdown-btn.open .dropdown-arrow {
+  transform: rotate(180deg);
+}
+
+.download-client-count {
+  background: var(--accent);
+  color: white;
+  padding: 1px 6px;
+  border-radius: 10px;
+  font-size: 0.75rem;
+  font-weight: 500;
+}
+
+/* Dropdown panel */
+.download-client-dropdown {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  margin-top: 4px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  min-width: 200px;
+  max-width: 300px;
+  max-height: 300px;
+  overflow-y: auto;
+  z-index: 1000;
+  display: none;
+}
+
+.download-client-dropdown.open {
+  display: block;
+}
+
+/* Dropdown header with Select All/Deselect All buttons */
+.download-client-dropdown-header {
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  gap: 8px;
+  position: sticky;
+  top: 0;
+  background: var(--surface);
+  z-index: 1;
+}
+
+.download-client-dropdown-btn-small {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  background: var(--surface-alt);
+  color: var(--text-secondary);
+  font-size: 0.75rem;
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+
+.download-client-dropdown-btn-small:hover {
+  background: var(--hover-bg);
+  color: var(--text-primary);
+}
+
+/* Client option row */
+.download-client-option {
+  padding: 8px 12px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  transition: background 0.15s;
+}
+
+.download-client-option:hover {
+  background: var(--hover-bg);
+}
+
+.download-client-checkbox {
+  width: 16px;
+  height: 16px;
+  margin: 0;
+  cursor: pointer;
+  accent-color: var(--accent);
+}
+
+.download-client-option-label {
+  flex: 1;
+  font-size: 0.85rem;
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.download-client-type {
+  font-size: 0.75rem;
+  color: var(--text-secondary);
+  background: var(--surface-alt);
+  padding: 1px 6px;
+  border-radius: 3px;
+}
+
+/* Empty state */
+.download-client-empty {
+  padding: 12px;
+  text-align: center;
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+}
+
+/* Client icon */
+.download-client-icon {
+  width: 20px;
+  height: 20px;
+  flex-shrink: 0;
+  display: inline-block;
+  vertical-align: middle;
+}
+
+.download-client-icon img {
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+}
+
+.download-client-icon.fallback {
+  font-size: 14px;
+  font-weight: bold;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--surface-alt);
+  border-radius: 3px;
+  color: var(--text-primary);
+}
+
+/* ===== Request Filters ===== */
+
+.requests-header {
+  /* Inherits from .tab-header */
+}
+
+.requests-controls {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.request-filter {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.request-filter-label {
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+}
+
+.request-filter-btn {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+  cursor: pointer;
+  min-width: 100px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  transition: background 0.15s, border-color 0.15s;
+}
+
+.request-filter-btn:hover {
+  background: var(--surface-alt);
+}
+
+.request-filter-btn:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.request-filter-btn .dropdown-arrow {
+  font-size: 0.75rem;
+  transition: transform 0.2s;
+}
+
+.request-filter-dropdown {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  margin-top: 4px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  min-width: 180px;
+  max-width: 280px;
+  max-height: 300px;
+  overflow-y: auto;
+  z-index: 1000;
+  display: none;
+}
+
+.request-filter-dropdown.open {
+  display: block;
+}
+
+.request-filter-dropdown-header {
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  gap: 8px;
+  position: sticky;
+  top: 0;
+  background: var(--surface);
+  z-index: 1;
+}
+
+.request-filter-dropdown-btn-small {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 3px;
+  background: var(--surface-alt);
+  color: var(--text-secondary);
+  font-size: 0.75rem;
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+
+.request-filter-dropdown-btn-small:hover {
+  background: var(--accent-light);
+  color: var(--text-primary);
+}
+
+.request-filter-options {
+  padding: 4px 0;
+}
+
+.request-filter-option {
+  padding: 8px 12px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  transition: background 0.15s;
+}
+
+.request-filter-option:hover {
+  background: var(--surface-alt);
+}
+
+.request-filter-checkbox {
+  width: 16px;
+  height: 16px;
+  margin: 0;
+  cursor: pointer;
+  accent-color: var(--accent);
+}
+
+.request-filter-option label {
+  flex: 1;
+  font-size: 0.85rem;
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.request-sort {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.request-sort-select {
+  padding: 4px 8px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+  cursor: pointer;
+}
+
+.request-sort-select:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.request-search {
+  display: inline-flex;
+  align-items: center;
+}
+
+.request-search-input {
+  padding: 4px 10px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--surface);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+  min-width: 160px;
+}
+
+.request-search-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.history-header {
+  /* Inherits from .tab-header */
 }
 
 .history-controls {
@@ -721,7 +1165,7 @@ body {
   display: inline-flex;
   align-items: center;
   gap: 5px;
-  font-size: 0.82rem;
+  font-size: 0.85rem;
   color: var(--text-secondary);
   cursor: pointer;
   user-select: none;
@@ -1196,7 +1640,6 @@ body {
   text-transform: capitalize;
   background: var(--accent-light);
   color: var(--accent);
-  margin-left: auto;
   white-space: nowrap;
 }
 
@@ -1206,6 +1649,52 @@ body {
   margin-left: 0;
 }
 
+/* Download client logo in card */
+.download-header-right {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 2px;
+  margin-left: auto;
+}
+
+.download-client-logo-wrapper {
+  width: 20px;
+  height: 20px;
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+/* Card-specific logo wrapper positioned at bottom right */
+.download-card-logo-wrapper {
+  width: 32px;
+  height: 32px;
+  position: absolute;
+  bottom: 8px;
+  right: 8px;
+}
+
+.download-client-logo {
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+}
+
+.download-client-logo-wrapper.fallback {
+  font-size: 10px;
+  font-weight: bold;
+  background: var(--surface-alt);
+  border-radius: 2px;
+  color: var(--text-primary);
+}
+
+.download-card-logo-wrapper.fallback {
+  font-size: 20px;
+  border-radius: 4px;
+}
+
 /* ===== Status Button ===== */
 .status-btn {
   padding: 4px 12px;
@@ -1430,6 +1919,23 @@ body {
 
 /* ===== Mobile ===== */
 @media (max-width: 768px) {
+  .main-tabs {
+    padding: 0 8px;
+  }
+
+  .requests-container {
+    padding: 8px;
+  }
+
+  .request-card {
+    gap: 8px;
+    padding: 10px;
+  }
+
+  .request-meta {
+    gap: 4px;
+  }
+
   .app {
     padding: 10px;
   }
@@ -1751,3 +2257,176 @@ body {
   font-size: 0.9rem;
   font-weight: 600;
 }
+
+/* ===== Requests Tab ===== */
+.requests-container {
+  background: var(--surface);
+  padding: 16px 20px;
+  border-radius: 8px;
+  box-shadow: 0 2px 4px var(--shadow);
+  transition: background 0.3s;
+}
+
+.requests-header {
+  /* Inherits from .tab-header */
+}
+
+.no-requests {
+  text-align: center;
+  padding: 40px 20px;
+  color: var(--text-muted);
+}
+
+.requests-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.request-card {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 10px 14px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  transition: box-shadow 0.2s ease, border-color 0.2s ease;
+  min-width: 0;
+}
+
+.request-card.tv {
+  border-left: 3px solid var(--series-color);
+}
+
+.request-card.movie {
+  border-left: 3px solid var(--movie-color);
+}
+
+.request-card:hover {
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+  border-color: var(--accent);
+}
+
+.request-type-icon {
+  font-size: 1.6rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 48px;
+  height: 68px;
+  background: var(--surface-alt);
+  border-radius: 4px;
+  box-shadow: 0 1px 4px var(--shadow-strong);
+  flex-shrink: 0;
+}
+
+.request-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.request-title {
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0 0 4px;
+  word-break: break-word;
+}
+
+.request-meta {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+}
+
+.request-status-badge {
+  padding: 2px 8px;
+  border-radius: 12px;
+  font-size: 0.75rem;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.request-status-badge.available {
+  background: var(--success-bg);
+  color: var(--success);
+}
+
+.request-status-badge.approved {
+  background: var(--info-bg);
+  color: var(--info);
+}
+
+.request-status-badge.denied {
+  background: var(--danger-bg);
+  color: var(--danger);
+}
+
+.request-status-badge.pending {
+  background: var(--surface-alt);
+  color: var(--text-muted);
+}
+
+.request-status-badge.unknown {
+  background: var(--surface-alt);
+  color: var(--text-muted);
+}
+
+.request-year {
+  color: var(--text-muted);
+}
+
+.request-user {
+  color: var(--text-secondary);
+}
+
+.request-quality {
+  background: var(--accent-light);
+  color: var(--accent);
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-size: 0.75rem;
+  font-weight: 600;
+}
+
+.request-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-shrink: 0;
+}
+
+.request-link {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 8px;
+  background: var(--surface-alt);
+  border-radius: 6px;
+  transition: background 0.2s ease;
+}
+
+.request-link:hover {
+  background: var(--accent-light);
+}
+
+.request-icon {
+  height: 20px;
+  width: 20px;
+}
+
+/* ===== Orphaned Download Styling ===== */
+.download-card.orphaned {
+  border-left: 3px dashed var(--border-color, #c8c8cc);
+  opacity: 0.95;
+}
+.download-client-logo-wrapper.orphaned-logo {
+  filter: grayscale(1) opacity(0.5);
+  cursor: help;
+}
+
+

public/swagger-auth-banner.js

@@ -0,0 +1,34 @@
+// Swagger UI authentication banner
+// This banner explains the cookie + CSRF authentication flow
+(function() {
+  window.addEventListener('load', function() {
+    const banner = document.createElement('div');
+    banner.style.cssText = `
+      background: #fff3cd;
+      border: 1px solid #ffc107;
+      border-radius: 4px;
+      padding: 12px 16px;
+      margin: 16px;
+      font-family: sans-serif;
+      font-size: 14px;
+      line-height: 1.5;
+      color: #856404;
+    `;
+    banner.innerHTML = `
+      <strong>Authentication Required for Most Endpoints</strong><br>
+      sofarr uses cookie-based authentication with Emby/Jellyfin. To test authenticated endpoints:<br>
+      1. Call <code>POST /api/auth/login</code> with your username and password<br>
+      2. The server sets an <code>emby_user</code> cookie and <code>csrf_token</code> cookie<br>
+      3. Include these cookies in subsequent requests<br>
+      4. For state-changing operations (POST/PUT/PATCH/DELETE), also send the <code>X-CSRF-Token</code> header<br>
+      <br>
+      <em>Note: The Swagger UI "Authorize" button is not used. Authentication is handled via cookies.</em>
+    `;
+    
+    // Insert after the topbar (which we hide with CSS) or at the top of the info section
+    const info = document.querySelector('.info');
+    if (info) {
+      info.insertBefore(banner, info.firstChild);
+    }
+  });
+})();

scripts/convert-to-raml.js

@@ -0,0 +1,61 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Converts OpenAPI 3.0 to RAML 1.0 using AMF (amf-client-js)
+ * AMF is the modern replacement for deprecated RAML converters.
+ */
+
+const { Main, AMFParser, AMFTransformer } = require('amf-client-js');
+const fs = require('fs');
+const path = require('path');
+
+const INPUT_FILE = path.join(process.cwd(), 'dist/openapi-30.json');
+const OUTPUT_FILE = path.join(process.cwd(), 'dist/api.raml');
+
+async function convertToRaml() {
+  if (!fs.existsSync(INPUT_FILE)) {
+    throw new Error(`Input file not found: ${INPUT_FILE}`);
+  }
+
+  console.log('Initializing AMF...');
+  await Main.init();
+
+  console.log(`Reading OpenAPI 3.0 spec from ${INPUT_FILE}`);
+  const specContent = fs.readFileSync(INPUT_FILE, 'utf-8');
+
+  console.log('Parsing OpenAPI spec...');
+  const parser = new AMFParser();
+  const model = await parser.parseStringAsync('file://' + INPUT_FILE, specContent, 'application/json');
+
+  console.log('Resolving references...');
+  const resolvedModel = await AMFTransformer.resolve(model);
+
+  console.log('Converting to RAML 1.0...');
+  const ramlModel = await AMFTransformer.transform(resolvedModel, 'RAML 1.0');
+
+  console.log('Generating RAML output...');
+  const ramlContent = await AMFTransformer.generateString(ramlModel, 'application/yaml');
+
+  // Clean up the output - AMF sometimes adds extra formatting
+  const cleanedRaml = ramlContent
+    .replace('#%RAML 1.0\n', '#%RAML 1.0\n\n')
+    .replace(/\n{3,}/g, '\n\n');
+
+  fs.writeFileSync(OUTPUT_FILE, cleanedRaml);
+  console.log(`✓ RAML spec written to ${OUTPUT_FILE}`);
+
+  // Basic validation
+  if (!cleanedRaml.includes('#%RAML 1.0')) {
+    throw new Error('Generated RAML does not appear to be valid RAML 1.0');
+  }
+
+  console.log('RAML conversion complete');
+}
+
+convertToRaml()
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error('Failed to convert to RAML:', error);
+    process.exit(1);
+  });

scripts/downgrade-openapi.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Downgrades OpenAPI 3.1.0 to 3.0.0 for compatibility with RAML converters.
+ * OpenAPI 3.1 has limited support in existing RAML conversion tools.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const INPUT_FILE = path.join(process.cwd(), 'dist/openapi-merged.json');
+const OUTPUT_FILE = path.join(process.cwd(), 'dist/openapi-30.json');
+
+function downgradeOpenApi30(spec) {
+  // Change version from 3.1.0 to 3.0.0
+  spec.openapi = '3.0.0';
+
+  // OpenAPI 3.1 uses "type" with array for nullable, 3.0 uses nullable: true
+  // This is a simple pass-through for now - complex schemas may need more handling
+  // For this spec, most nullable fields are already using 3.0-compatible syntax
+
+  return spec;
+}
+
+async function main() {
+  if (!fs.existsSync(INPUT_FILE)) {
+    throw new Error(`Input file not found: ${INPUT_FILE}`);
+  }
+
+  console.log(`Reading OpenAPI 3.1 spec from ${INPUT_FILE}`);
+  const spec = JSON.parse(fs.readFileSync(INPUT_FILE, 'utf-8'));
+
+  console.log('Downgrading to OpenAPI 3.0.0...');
+  const downgraded = downgradeOpenApi30(spec);
+
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(downgraded, null, 2));
+  console.log(`✓ Downgraded spec written to ${OUTPUT_FILE}`);
+}
+
+main()
+  .then(() => {
+    console.log('Downgrade complete');
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error('Failed to downgrade spec:', error);
+    process.exit(1);
+  });

scripts/generate-openapi.js

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Generates the merged OpenAPI spec by bootstrapping the Express app
+ * and fetching the spec from /api/swagger.json.
+ *
+ * This ensures the generated spec matches exactly what users see in production.
+ */
+
+const { createApp } = require('../server/app.js');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = 34567; // Use a different port to avoid conflicts
+const OUTPUT_DIR = path.join(process.cwd(), 'dist');
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'openapi-merged.json');
+
+async function generateOpenApiSpec() {
+  // Ensure output directory exists
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+
+  console.log('Bootstrapping Express app in test mode...');
+  const app = createApp({ skipRateLimits: true });
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(app);
+
+    server.listen(PORT, () => {
+      console.log(`Server listening on port ${PORT}`);
+
+      // Fetch the merged spec
+      const options = {
+        hostname: 'localhost',
+        port: PORT,
+        path: '/api/swagger.json',
+        method: 'GET'
+      };
+
+      const req = http.request(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const spec = JSON.parse(data);
+
+            // Validate it's a proper OpenAPI spec
+            if (!spec.openapi || !spec.info) {
+              throw new Error('Invalid OpenAPI spec: missing openapi or info field');
+            }
+
+            // Write to file
+            fs.writeFileSync(OUTPUT_FILE, JSON.stringify(spec, null, 2));
+            console.log(`✓ OpenAPI spec written to ${OUTPUT_FILE}`);
+            console.log(`  Version: ${spec.openapi}`);
+            console.log(`  Title: ${spec.info.title}`);
+
+            server.close(() => {
+              resolve();
+            });
+          } catch (error) {
+            console.error('Error processing OpenAPI spec:', error.message);
+            server.close(() => {
+              reject(error);
+            });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        console.error('Error fetching spec:', error.message);
+        server.close(() => {
+          reject(error);
+        });
+      });
+
+      req.end();
+    });
+
+    server.on('error', (error) => {
+      if (error.code === 'EADDRINUSE') {
+        reject(new Error(`Port ${PORT} is already in use`));
+      } else {
+        reject(error);
+      }
+    });
+  });
+}
+
+// Run if executed directly
+if (require.main === module) {
+  generateOpenApiSpec()
+    .then(() => {
+      console.log('OpenAPI spec generation complete');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('Failed to generate OpenAPI spec:', error);
+      process.exit(1);
+    });
+}
+
+module.exports = { generateOpenApiSpec };

scripts/package-raml.js

@@ -0,0 +1,184 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Creates a versioned tar.gz archive containing the RAML spec,
+ * original OpenAPI spec, version metadata, and README.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const archiver = require('archiver');
+
+const DIST_DIR = path.join(process.cwd(), 'dist');
+const RAML_FILE = path.join(DIST_DIR, 'api.raml');
+const OPENAPI_FILE = path.join(DIST_DIR, 'openapi-merged.json');
+
+function getVersion() {
+  try {
+    // Try to get the exact tag if we're on one
+    const tag = execSync('git describe --tags --exact-match 2>/dev/null', { encoding: 'utf-8' }).trim();
+    if (tag) return tag;
+  } catch (e) {
+    // Not on a tag, fall back to SHA
+  }
+
+  try {
+    // Get short commit SHA
+    const sha = execSync('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim();
+    return sha;
+  } catch (e) {
+    // Not in a git repo, use timestamp
+    return `dev-${Date.now()}`;
+  }
+}
+
+function getCommitSha() {
+  try {
+    return execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+function createVersionJson(version, commitSha) {
+  return {
+    version,
+    commit: commitSha,
+    generatedAt: new Date().toISOString(),
+    tool: 'oas3-to-raml',
+    openapiVersion: '3.1.0',
+    ramlVersion: '1.0'
+  };
+}
+
+function createReadme(version, commitSha) {
+  return `# sofarr RAML 1.0 Specification
+
+## Origin
+
+This RAML specification was automatically generated from the sofarr OpenAPI 3.1.0 specification.
+
+- **Version:** ${version}
+- **Commit:** ${commitSha}
+- **Generated At:** ${new Date().toISOString()}
+- **Conversion Tool:** oas3-to-raml (npx)
+
+## Contents
+
+- \`api.raml\` - The RAML 1.0 specification
+- \`openapi-merged.json\` - Original merged OpenAPI 3.1.0 spec (for reference)
+- \`version.json\` - Metadata about this generation
+
+## Known Limitations
+
+This RAML spec was converted from OpenAPI 3.1.0. Some OpenAPI 3.1 features may not translate perfectly to RAML 1.0:
+
+- Cookie-based authentication (CookieAuth) may require manual mapping to RAML security schemes
+- Advanced schema features (e.g., certain keywords, complex polymorphism) may be approximated or dropped
+- Webhook-specific features may not be fully represented
+
+For the most accurate API documentation, refer to the live Swagger UI at \`/api/swagger\` or the original OpenAPI spec included in this archive.
+
+## Verification Steps
+
+1. Validate the RAML spec:
+   \`\`\`bash
+   npx raml-1-parser validate api.raml
+   \`\`\`
+
+2. Compare endpoints with the live Swagger UI at \`/api/swagger\`
+
+3. Test in a RAML-aware tool (e.g., API Workbench, MuleSoft Anypoint)
+
+## Quick Start
+
+To use this RAML spec:
+
+1. Extract the archive
+2. Open \`api.raml\` in your preferred RAML tool
+3. For development, import it into API Workbench or similar tools
+
+## Source
+
+This artifact was generated from the sofarr project:
+https://git.i3omb.com/Gandalf/sofarr
+
+Generated from CI run on commit ${commitSha}.
+`;
+}
+
+async function packageRaml() {
+  const version = getVersion();
+  const commitSha = getCommitSha();
+  const archiveName = `raml-${version}`;
+  const archivePath = path.join(DIST_DIR, `${archiveName}.tar.gz`);
+  const stagingDir = path.join(DIST_DIR, archiveName);
+
+  console.log(`Packaging RAML for version: ${version}`);
+  console.log(`Commit: ${commitSha}`);
+
+  // Check that required files exist
+  if (!fs.existsSync(RAML_FILE)) {
+    throw new Error(`RAML file not found: ${RAML_FILE}`);
+  }
+  if (!fs.existsSync(OPENAPI_FILE)) {
+    throw new Error(`OpenAPI file not found: ${OPENAPI_FILE}`);
+  }
+
+  // Create staging directory
+  if (fs.existsSync(stagingDir)) {
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(stagingDir, { recursive: true });
+
+  // Copy files to staging directory
+  fs.copyFileSync(RAML_FILE, path.join(stagingDir, 'api.raml'));
+  fs.copyFileSync(OPENAPI_FILE, path.join(stagingDir, 'openapi-merged.json'));
+
+  // Create version.json
+  const versionJson = createVersionJson(version, commitSha);
+  fs.writeFileSync(path.join(stagingDir, 'version.json'), JSON.stringify(versionJson, null, 2));
+
+  // Create README.md
+  const readme = createReadme(version, commitSha);
+  fs.writeFileSync(path.join(stagingDir, 'README.md'), readme);
+
+  // Create tar.gz archive
+  console.log(`Creating archive: ${archivePath}`);
+  const output = fs.createWriteStream(archivePath);
+  const archive = archiver('tar', { gzip: true });
+
+  return new Promise((resolve, reject) => {
+    output.on('close', () => {
+      console.log(`✓ Archive created: ${archivePath}`);
+      console.log(`  Size: ${archive.pointer()} bytes`);
+      resolve();
+    });
+
+    archive.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+    archive.directory(stagingDir, false);
+    archive.finalize();
+  }).then(() => {
+    // Clean up staging directory
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+  });
+}
+
+// Run if executed directly
+if (require.main === module) {
+  packageRaml()
+    .then(() => {
+      console.log('RAML packaging complete');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('Failed to package RAML:', error);
+      process.exit(1);
+    });
+}
+
+module.exports = { packageRaml };

scripts/simple-raml-converter.js

@@ -0,0 +1,183 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Simple OpenAPI 3.0 to RAML 1.0 converter.
+ * This is a basic converter that handles the essential parts of the sofarr API.
+ * For a production system, you'd want a more sophisticated converter.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const INPUT_FILE = path.join(process.cwd(), 'dist/openapi-30.json');
+const OUTPUT_FILE = path.join(process.cwd(), 'dist/api.raml');
+
+function convertToRaml(spec) {
+  const lines = [];
+  
+  // RAML header
+  lines.push('#%RAML 1.0');
+  lines.push('');
+  
+  // Title and version
+  lines.push(`title: ${spec.info.title}`);
+  if (spec.info.version) {
+    lines.push(`version: ${spec.info.version}`);
+  }
+  if (spec.info.description) {
+    lines.push(`description: |`);
+    spec.info.description.split('\n').forEach(line => {
+      lines.push(`  ${line}`);
+    });
+  }
+  lines.push('');
+  
+  // Base URI
+  if (spec.servers && spec.servers.length > 0) {
+    lines.push(`baseUri: ${spec.servers[0].url}`);
+    lines.push('');
+  }
+  
+  // Security Schemes
+  if (spec.components && spec.components.securitySchemes) {
+    lines.push('securitySchemes:');
+    for (const [name, scheme] of Object.entries(spec.components.securitySchemes)) {
+      lines.push(`  ${name}:`);
+      if (scheme.type === 'apiKey') {
+        lines.push(`    type: Api Key`);
+        lines.push(`    describedBy:`);
+        lines.push(`      headers:`);
+        lines.push(`        Authorization:`);
+        lines.push(`          description: API key for authentication`);
+        lines.push(`          type: string`);
+      } else if (scheme.type === 'http' && scheme.scheme === 'bearer') {
+        lines.push(`    type: OAuth 2.0`);
+        lines.push(`    settings:`);
+        lines.push(`      authorizationUri: ${scheme.bearerFormat || 'Bearer'}`);
+      }
+    }
+    lines.push('');
+  }
+  
+  // Types (schemas)
+  if (spec.components && spec.components.schemas) {
+    lines.push('types:');
+    for (const [name, schema] of Object.entries(spec.components.schemas)) {
+      lines.push(`  ${name}:`);
+      if (schema.type === 'object') {
+        lines.push(`    type: object`);
+        if (schema.properties) {
+          lines.push(`    properties:`);
+          for (const [propName, prop] of Object.entries(schema.properties)) {
+            lines.push(`      ${propName}:`);
+            lines.push(`        type: ${mapJsonTypeToRaml(prop.type || 'string')}`);
+            if (prop.description) {
+              lines.push(`        description: ${prop.description}`);
+            }
+          }
+        }
+      } else {
+        lines.push(`    type: ${mapJsonTypeToRaml(schema.type || 'string')}`);
+      }
+    }
+    lines.push('');
+  }
+  
+  // Paths
+  if (spec.paths) {
+    for (const [path, pathItem] of Object.entries(spec.paths)) {
+      lines.push(`/${path.replace(/^\//, '')}:`);
+      
+      // Methods
+      for (const [method, operation] of Object.entries(pathItem)) {
+        if (['get', 'post', 'put', 'delete', 'patch'].includes(method)) {
+          lines.push(`  ${method}:`);
+          if (operation.summary) {
+            lines.push(`    displayName: ${operation.summary}`);
+          }
+          if (operation.description) {
+            lines.push(`    description: |`);
+            operation.description.split('\n').forEach(line => {
+              lines.push(`      ${line}`);
+            });
+          }
+          
+          // Query parameters
+          if (operation.parameters) {
+            const queryParams = operation.parameters.filter(p => p.in === 'query');
+            if (queryParams.length > 0) {
+              lines.push(`    queryParameters:`);
+              queryParams.forEach(param => {
+                lines.push(`      ${param.name}:`);
+                lines.push(`        type: ${mapJsonTypeToRaml(param.schema?.type || 'string')}`);
+                lines.push(`        required: ${param.required || false}`);
+                if (param.description) {
+                  lines.push(`        description: ${param.description}`);
+                }
+              });
+            }
+          }
+          
+          // Responses
+          if (operation.responses) {
+            lines.push(`    responses:`);
+            for (const [code, response] of Object.entries(operation.responses)) {
+              lines.push(`      ${code}:`);
+              if (response.description) {
+                lines.push(`        description: ${response.description}`);
+              }
+              if (response.content && response.content['application/json']) {
+                const schema = response.content['application/json'].schema;
+                if (schema && schema.$ref) {
+                  const refName = schema.$ref.replace('#/components/schemas/', '');
+                  lines.push(`        body:`);
+                  lines.push(`          application/json:`);
+                  lines.push(`            type: ${refName}`);
+                }
+              }
+            }
+          }
+        }
+      }
+      lines.push('');
+    }
+  }
+  
+  return lines.join('\n');
+}
+
+function mapJsonTypeToRaml(jsonType) {
+  const typeMap = {
+    'string': 'string',
+    'integer': 'integer',
+    'number': 'number',
+    'boolean': 'boolean',
+    'array': 'array',
+    'object': 'object'
+  };
+  return typeMap[jsonType] || 'string';
+}
+
+async function main() {
+  if (!fs.existsSync(INPUT_FILE)) {
+    throw new Error(`Input file not found: ${INPUT_FILE}`);
+  }
+
+  console.log(`Reading OpenAPI 3.0 spec from ${INPUT_FILE}`);
+  const spec = JSON.parse(fs.readFileSync(INPUT_FILE, 'utf-8'));
+
+  console.log('Converting to RAML 1.0...');
+  const ramlContent = convertToRaml(spec);
+
+  fs.writeFileSync(OUTPUT_FILE, ramlContent);
+  console.log(`✓ RAML spec written to ${OUTPUT_FILE}`);
+  console.log('RAML conversion complete');
+}
+
+main()
+  .then(() => {
+    process.exit(0);
+  })
+  .catch((error) => {
+    console.error('Failed to convert to RAML:', error);
+    process.exit(1);
+  });

server/app.js

@@ -11,20 +11,47 @@ const cookieParser = require('cookie-parser');
 const helmet = require('helmet');
 const rateLimit = require('express-rate-limit');
 const crypto = require('crypto');
+const swaggerUi = require('swagger-ui-express');
+const swaggerJsdoc = require('swagger-jsdoc');
+const YAML = require('yamljs');
+const path = require('path');
+const fs = require('fs');
+const { version } = require('../package.json');
 
 const sabnzbdRoutes = require('./routes/sabnzbd');
 const sonarrRoutes = require('./routes/sonarr');
 const radarrRoutes = require('./routes/radarr');
 const embyRoutes = require('./routes/emby');
 const dashboardRoutes = require('./routes/dashboard');
+const statusRoutes = require('./routes/status');
 const historyRoutes = require('./routes/history');
 const authRoutes = require('./routes/auth');
 const webhookRoutes = require('./routes/webhook');
+const ombiRoutes = require('./routes/ombi');
+const debugRoutes = require('./routes/debug');
 const verifyCsrf = require('./middleware/verifyCsrf');
 
 function createApp({ skipRateLimits = false } = {}) {
   const app = express();
 
+  // Load OpenAPI spec from YAML
+  const openapiSpec = YAML.load(path.join(__dirname, 'openapi.yaml'));
+
+  // Configure swagger-jsdoc to merge JSDoc comments from route files
+  const swaggerOptions = {
+    definition: {
+      ...openapiSpec,
+      openapi: '3.1.0'
+    },
+    apis: [
+      path.join(__dirname, 'routes/*.js'),
+      path.join(__dirname, 'app.js'),
+      path.join(__dirname, 'index.js')
+    ]
+  };
+
+  const swaggerSpec = swaggerJsdoc(swaggerOptions);
+
   if (process.env.TRUST_PROXY) {
     const trustValue = /^\d+$/.test(process.env.TRUST_PROXY)
       ? parseInt(process.env.TRUST_PROXY, 10)
@@ -72,6 +99,7 @@ function createApp({ skipRateLimits = false } = {}) {
     max: skipRateLimits ? Number.MAX_SAFE_INTEGER : 300,
     standardHeaders: true,
     legacyHeaders: false,
+    skip: (req) => req.originalUrl && req.originalUrl.startsWith('/api/dashboard/cover-art'),
     message: { error: 'Too many requests, please try again later' }
   });
 
@@ -79,10 +107,79 @@ function createApp({ skipRateLimits = false } = {}) {
   app.use(express.json({ limit: '64kb' }));
 
   // Health / readiness (no auth, no rate-limit)
+  /**
+   * @openapi
+   * /health:
+   *   get:
+   *     tags: [Health]
+   *     summary: Health check
+   *     description: Returns server uptime and status. No authentication required. Used for liveness probes.
+   *     security: []
+   *     responses:
+   *       '200':
+   *         description: Server is healthy
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 status:
+   *                   type: string
+   *                   example: "ok"
+   *                 uptime:
+   *                   type: number
+   *                   description: Server uptime in seconds
+   *                   example: 3600.5
+   *                 version:
+   *                   type: string
+   *                   description: sofarr version
+   *                   example: "1.7.35"
+   *     x-code-samples:
+   *       - lang: curl
+   *         label: cURL
+   *         source: curl http://localhost:3001/health
+   */
   app.get('/health', (req, res) => {
-    res.json({ status: 'ok', uptime: process.uptime() });
+    res.json({ status: 'ok', uptime: process.uptime(), version });
   });
 
+  /**
+   * @openapi
+   * /ready:
+   *   get:
+   *     tags: [Health]
+   *     summary: Readiness check
+   *     description: Checks if critical configuration (EMBY_URL) is present. Used by Docker HEALTHCHECK and orchestrators. No authentication required.
+   *     security: []
+   *     responses:
+   *       '200':
+   *         description: Server is ready
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 status:
+   *                   type: string
+   *                   example: "ready"
+   *       '503':
+   *         description: Server not ready
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 status:
+   *                   type: string
+   *                   example: "not ready"
+   *                 reason:
+   *                   type: string
+   *                   example: "EMBY_URL not configured"
+   *     x-code-samples:
+   *       - lang: curl
+   *         label: cURL
+   *         source: curl http://localhost:3001/ready
+   */
   app.get('/ready', (req, res) => {
     const ready = !!(process.env.EMBY_URL);
     if (ready) {
@@ -92,10 +189,38 @@ function createApp({ skipRateLimits = false } = {}) {
     }
   });
 
+  // Swagger UI - publicly accessible API documentation
+  app.use('/api/swagger', swaggerUi.serve, swaggerUi.setup(null, {
+    customSiteTitle: 'sofarr API Documentation',
+    customCss: '.swagger-ui .topbar { display: none }',
+    customJs: [
+      '/swagger-auth-banner.js'
+    ],
+    swaggerOptions: {
+      url: '/api/swagger.json'
+    }
+  }));
+
+  // Serve the raw OpenAPI spec as JSON with dynamic server URL
+  app.get('/api/swagger.json', (req, res) => {
+    // Clone the spec to avoid modifying the original
+    const specCopy = JSON.parse(JSON.stringify(swaggerSpec));
+    
+    // Replace the server URL with the current request's origin
+    if (specCopy.servers && specCopy.servers.length > 0) {
+      const protocol = req.protocol;
+      const host = req.get('host');
+      specCopy.servers[0].url = `${protocol}://${host}`;
+    }
+    
+    res.json(specCopy);
+  });
+
   // API routes
   app.use('/api', apiLimiter);
   app.use('/api/auth', authRoutes);
   app.use('/api/webhook', webhookRoutes);
+  app.use('/api/debug', debugRoutes);
 
   // CSRF protection for all state-changing API requests below
   app.use('/api', verifyCsrf);
@@ -103,9 +228,49 @@ function createApp({ skipRateLimits = false } = {}) {
   app.use('/api/sonarr', sonarrRoutes);
   app.use('/api/radarr', radarrRoutes);
   app.use('/api/emby', embyRoutes);
+  app.use('/api/ombi', ombiRoutes);
   app.use('/api/dashboard', dashboardRoutes);
+  app.use('/api/status', statusRoutes);
   app.use('/api/history', historyRoutes);
 
+  // ---------------------------------------------------------------------------
+  // Static files — served before API routes
+  // index.html is served manually so we can inject the CSP nonce
+  // ---------------------------------------------------------------------------
+  const PUBLIC_DIR = path.join(__dirname, '../public');
+  const INDEX_HTML = path.join(PUBLIC_DIR, 'index.html');
+
+  // Serve all static assets (js, css, images, icons) except index.html.
+  // JS and CSS get no-cache so browsers revalidate on every load (ETag still
+  // avoids re-downloading unchanged files; only a deploy changes the ETag).
+  app.use(express.static(PUBLIC_DIR, {
+    index: false,
+    setHeaders(res, filePath) {
+      if (filePath.endsWith('.js') || filePath.endsWith('.css')) {
+        res.setHeader('Cache-Control', 'no-cache');
+      }
+    }
+  }));
+
+  // Serve index.html with CSP nonce injected into <script> tags
+  function serveIndex(req, res) {
+    fs.readFile(INDEX_HTML, 'utf8', (err, html) => {
+      if (err) return res.status(500).send('Internal Server Error');
+      const nonce = res.locals.cspNonce;
+      // Only inject nonce into <script> tags — style-src 'self' already permits
+      // same-origin <link rel=stylesheet> without a nonce, and injecting a nonce
+      // onto <link> breaks mobile browsers / caching proxies (stale HTML carries
+      // the old nonce which no longer matches the per-request CSP header).
+      const patched = html
+        .replace(/<script([^>]*)>/gi, `<script nonce="${nonce}"$1>`);
+      res.setHeader('Content-Type', 'text/html; charset=utf-8');
+      res.send(patched);
+    });
+  }
+
+  // SPA catch-all — serve index.html for any unmatched path
+  app.get('*', serveIndex);
+
   // Global error handler
   // eslint-disable-next-line no-unused-vars
   app.use((err, req, res, next) => {

server/clients/DownloadClient.js

@@ -25,6 +25,41 @@ class DownloadClient {
     this.apiKey = instanceConfig.apiKey;
     this.username = instanceConfig.username;
     this.password = instanceConfig.password;
+
+    // Last error encountered while talking to this client.
+    // Cleared on successful calls via _clearLastError(); set via _recordLastError().
+    // Surfaced through getAllClientStatuses() so the admin status panel can show
+    // a per-client failure indicator without needing to scrape logs.
+    this.lastError = null;
+  }
+
+  /**
+   * Record an error encountered while talking to this client.
+   * @param {string} operation - Short description of the operation (e.g. 'getActiveDownloads')
+   * @param {Error|string} error - Error object or message
+   */
+  _recordLastError(operation, error) {
+    const message = (error && error.message) ? error.message : String(error || 'unknown error');
+    this.lastError = {
+      operation,
+      message,
+      at: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Clear the last error (called when an operation succeeds).
+   */
+  _clearLastError() {
+    this.lastError = null;
+  }
+
+  /**
+   * Public accessor for the last recorded error, or null if none.
+   * @returns {{operation:string, message:string, at:string}|null}
+   */
+  getLastError() {
+    return this.lastError;
   }
 
   /**

server/clients/OmbiClient.js

@@ -0,0 +1,144 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const axios = require('axios');
+const { logToFile } = require('../utils/logger');
+
+/**
+ * Ombi API client for fetching requests and searching media.
+ * Provides integration with Ombi request management system.
+ */
+class OmbiClient {
+  constructor(url, apiKey) {
+    this.url = url.replace(/\/$/, ''); // Remove trailing slash
+    this.apiKey = apiKey;
+    this.axios = axios.create({
+      headers: { 'ApiKey': this.apiKey },
+      timeout: 10000
+    });
+  }
+
+  /**
+   * Get all movie requests from Ombi
+   * @returns {Promise<Array>} Array of movie request objects
+   */
+  async getMovieRequests() {
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Request/movie`);
+      return response.data || [];
+    } catch (error) {
+      logToFile(`[OmbiClient] Movie requests error: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Get all TV requests from Ombi
+   * @returns {Promise<Array>} Array of TV request objects
+   */
+  async getTvRequests() {
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Request/tv`);
+      return response.data || [];
+    } catch (error) {
+      logToFile(`[OmbiClient] TV requests error: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Search for movies by TMDB ID
+   * @param {string} tmdbId - TheMovieDB ID
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchMovieByTmdbId(tmdbId) {
+    if (!tmdbId) return null;
+    
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Search/movie/${tmdbId}`);
+      return response.data || null;
+    } catch (error) {
+      logToFile(`[OmbiClient] Movie search error for TMDB ID ${tmdbId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Search for movies by IMDB ID
+   * @param {string} imdbId - IMDB ID
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchMovieByImdbId(imdbId) {
+    if (!imdbId) return null;
+    
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Search/movie/imdb/${imdbId}`);
+      return response.data || null;
+    } catch (error) {
+      logToFile(`[OmbiClient] Movie search error for IMDB ID ${imdbId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Search for TV shows by TVDB ID
+   * @param {string} tvdbId - TheTVDB ID
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchTvByTvdbId(tvdbId) {
+    if (!tvdbId) return null;
+    
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Search/tv/${tvdbId}`);
+      return response.data || null;
+    } catch (error) {
+      logToFile(`[OmbiClient] TV search error for TVDB ID ${tvdbId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Search for TV shows by TMDB ID
+   * @param {string} tmdbId - TheMovieDB ID
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchTvByTmdbId(tmdbId) {
+    if (!tmdbId) return null;
+    
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Search/tv/tmdb/${tmdbId}`);
+      return response.data || null;
+    } catch (error) {
+      logToFile(`[OmbiClient] TV search error for TMDB ID ${tmdbId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Test connection to Ombi API
+   * @returns {Promise<boolean>} True if connection is successful
+   */
+  async testConnection() {
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Request/movie`);
+      return response.status === 200;
+    } catch (error) {
+      logToFile(`[OmbiClient] Connection test failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Get all users from Ombi
+   * @returns {Promise<Array>} Array of user objects
+   */
+  async getUsers() {
+    try {
+      const response = await this.axios.get(`${this.url}/api/v1/Identity/Users`);
+      return response.data || [];
+    } catch (error) {
+      logToFile(`[OmbiClient] Get users error: ${error.message}`);
+      return [];
+    }
+  }
+}
+
+module.exports = OmbiClient;

server/clients/OmbiRetriever.js

@@ -0,0 +1,366 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const ArrRetriever = require('./ArrRetriever');
+const OmbiClient = require('./OmbiClient');
+const { logToFile } = require('../utils/logger');
+
+/**
+ * Ombi data retriever with caching support.
+ * Extends ArrRetriever for PALDRA compliance.
+ * Manages Ombi request data and provides lookup maps for efficient matching.
+ */
+class OmbiRetriever extends ArrRetriever {
+  constructor(instanceConfig) {
+    super(instanceConfig);
+    this.client = new OmbiClient(this.url, this.apiKey);
+    this.baseUrl = this.url;
+    this.cache = {
+      movieRequests: [],
+      tvRequests: [],
+      users: [],
+      movieMap: new Map(), // tmdbId -> request
+      tvMap: new Map(),    // tvdbId -> request
+      userMap: new Map(),  // id -> user
+      lastFetch: 0,
+      ttl: 5 * 60 * 1000  // 5 minutes TTL
+    };
+  }
+
+  /**
+   * Get retriever type
+   * @returns {string} The retriever type
+   */
+  getRetrieverType() {
+    return 'ombi';
+  }
+
+  /**
+   * Get the unique instance ID
+   * @returns {string} The instance ID
+   */
+  getInstanceId() {
+    return this.id;
+  }
+
+  /**
+   * Get tags from Ombi (not applicable, returns empty array)
+   * @returns {Promise<Array>} Empty array (Ombi doesn't have tags)
+   */
+  async getTags() {
+    return [];
+  }
+
+  /**
+   * Get queue from Ombi (active requests)
+   * @returns {Promise<Object>} Queue object with records array
+   */
+  async getQueue() {
+    await this.refreshCache();
+    return {
+      records: [...this.cache.movieRequests, ...this.cache.tvRequests]
+    };
+  }
+
+  /**
+   * Get history from Ombi (not applicable, returns empty records)
+   * @param {Object} options - Optional parameters (ignored for Ombi)
+   * @returns {Promise<Object>} History object with empty records array
+   */
+  async getHistory(options = {}) {
+    return {
+      records: []
+    };
+  }
+
+  /**
+   * Test connection to Ombi
+   * @returns {Promise<boolean>} True if connection is successful
+   */
+  async testConnection() {
+    return await this.client.testConnection();
+  }
+
+  /**
+   * Check if cache is expired
+   * @returns {boolean} True if cache needs refresh
+   */
+  isCacheExpired() {
+    return Date.now() - this.cache.lastFetch > this.cache.ttl;
+  }
+
+  /**
+   * Refresh cached data from Ombi API
+   * @param {boolean} force - Whether to force a refresh regardless of TTL
+   * @returns {Promise<void>}
+   */
+  async refreshCache(force = false) {
+    if (!force && !this.isCacheExpired()) {
+      return;
+    }
+
+    try {
+      logToFile('[OmbiRetriever] Refreshing cache');
+      
+      // Fetch requests and users in parallel
+      const [movieRequests, tvRequests, users] = await Promise.all([
+        this.client.getMovieRequests(),
+        this.client.getTvRequests(),
+        this.client.getUsers()
+      ]);
+
+      // Update cache
+      this.cache.movieRequests = movieRequests;
+      this.cache.tvRequests = tvRequests;
+      this.cache.users = users;
+      this.cache.lastFetch = Date.now();
+
+      // Build lookup maps
+      this.cache.movieMap.clear();
+      this.cache.tvMap.clear();
+      this.cache.userMap.clear();
+
+      // Build user map (id -> user)
+      if (Array.isArray(users)) {
+        users.forEach(user => {
+          if (user && user.id) {
+            this.cache.userMap.set(user.id, user);
+          }
+        });
+      }
+
+      // Build movie map (tmdbId -> request)
+      movieRequests.forEach(request => {
+        if (request.theMovieDbId) {
+          this.cache.movieMap.set(request.theMovieDbId, request);
+        }
+        if (request.imdbId) {
+          this.cache.movieMap.set(request.imdbId, request);
+        }
+      });
+
+      // Build TV map (tvdbId -> request, fallback to tmdbId)
+      tvRequests.forEach(request => {
+        if (request.theTvDbId) {
+          this.cache.tvMap.set(request.theTvDbId, request);
+        }
+        if (request.theMovieDbId) {
+          this.cache.tvMap.set(request.theMovieDbId, request);
+        }
+      });
+
+      logToFile(`[OmbiRetriever] Cache refreshed: ${movieRequests.length} movies, ${tvRequests.length} TV shows, ${users.length} users`);
+    } catch (error) {
+      logToFile(`[OmbiRetriever] Cache refresh failed: ${error.message}`);
+      // Don't throw error, continue with stale cache if available
+    }
+  }
+
+  /**
+   * Hydrates requestedUser on a single request using the userMap cache
+   * @param {Object} req - The request object
+   * @returns {Object} Hydrated request object
+   * @private
+   */
+  _hydrateRequest(req) {
+    if (!req) return req;
+
+    let result = req;
+
+    const reqUserId = req.requestedUserId || req.RequestedUserId;
+    if (reqUserId && this.cache.userMap.has(reqUserId)) {
+      const cachedUser = this.cache.userMap.get(reqUserId);
+
+      let requestedUser = req.requestedUser || req.RequestedUser;
+
+      // If requestedUser is not an object or is empty/null, populate it
+      if (!requestedUser || typeof requestedUser !== 'object' || Object.keys(requestedUser).length === 0) {
+        const hydratedUser = {
+          id: cachedUser.id,
+          userName: cachedUser.userName,
+          alias: cachedUser.alias || cachedUser.Alias || '',
+          userAlias: cachedUser.userAlias || cachedUser.UserAlias || '',
+          normalizedUserName: cachedUser.normalizedUserName || cachedUser.NormalizedUserName || ''
+        };
+
+        result = {
+          ...req,
+          requestedUser: hydratedUser,
+          RequestedUser: hydratedUser
+        };
+      }
+    }
+
+    // Hydrate childRequests (common for Ombi TV show requests)
+    if (Array.isArray(result.childRequests) && result.childRequests.length > 0) {
+      const hydratedChildren = result.childRequests.map(child => {
+        if (!child) return child;
+
+        const childUserId = child.requestedUserId || child.RequestedUserId;
+        if (childUserId && this.cache.userMap.has(childUserId)) {
+          const cachedUser = this.cache.userMap.get(childUserId);
+          let childUser = child.requestedUser || child.RequestedUser;
+
+          if (!childUser || typeof childUser !== 'object' || Object.keys(childUser).length === 0) {
+            const hydratedUser = {
+              id: cachedUser.id,
+              userName: cachedUser.userName,
+              alias: cachedUser.alias || cachedUser.Alias || '',
+              userAlias: cachedUser.userAlias || cachedUser.UserAlias || '',
+              normalizedUserName: cachedUser.normalizedUserName || cachedUser.NormalizedUserName || ''
+            };
+
+            return {
+              ...child,
+              requestedUser: hydratedUser,
+              RequestedUser: hydratedUser
+            };
+          }
+        }
+        return child;
+      });
+
+      result = { ...result, childRequests: hydratedChildren };
+    }
+
+    // Promote requestedDate from childRequests to top level (common for Ombi TV)
+    if (!result.requestedDate && Array.isArray(result.childRequests) && result.childRequests.length > 0) {
+      const childDate = result.childRequests[0].requestedDate || result.childRequests[0].RequestedDate;
+      if (childDate) {
+        result = { ...result, requestedDate: childDate };
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Hydrates requestedUser on a list of requests using the userMap cache
+   * @param {Array} requests - Array of request objects
+   * @returns {Array} Array of hydrated request objects
+   * @private
+   */
+  _hydrateRequests(requests) {
+    if (!Array.isArray(requests)) return [];
+    return requests.map(req => this._hydrateRequest(req));
+  }
+
+  /**
+   * Get all movie requests
+   * @param {boolean} force - Whether to force refresh from API
+   * @returns {Promise<Array>} Array of movie request objects
+   */
+  async getMovieRequests(force = false) {
+    await this.refreshCache(force);
+    return this._hydrateRequests(this.cache.movieRequests);
+  }
+
+  /**
+   * Get all TV requests
+   * @param {boolean} force - Whether to force refresh from API
+   * @returns {Promise<Array>} Array of TV request objects
+   */
+  async getTvRequests(force = false) {
+    await this.refreshCache(force);
+    return this._hydrateRequests(this.cache.tvRequests);
+  }
+
+  /**
+   * Find movie request by external ID
+   * @param {string} tmdbId - TheMovieDB ID
+   * @param {string} imdbId - IMDB ID (optional fallback)
+   * @returns {Promise<Object|null>} Request object or null if not found
+   */
+  async findMovieRequest(tmdbId, imdbId = null) {
+    await this.refreshCache();
+    
+    // Try TMDB ID first
+    if (tmdbId && this.cache.movieMap.has(tmdbId)) {
+      return this._hydrateRequest(this.cache.movieMap.get(tmdbId));
+    }
+    
+    // Try IMDB ID as fallback
+    if (imdbId && this.cache.movieMap.has(imdbId)) {
+      return this._hydrateRequest(this.cache.movieMap.get(imdbId));
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find TV request by external ID
+   * @param {string} tvdbId - TheTVDB ID
+   * @param {string} tmdbId - TheMovieDB ID (optional fallback)
+   * @returns {Promise<Object|null>} Request object or null if not found
+   */
+  async findTvRequest(tvdbId, tmdbId = null) {
+    await this.refreshCache();
+    
+    // Try TVDB ID first
+    if (tvdbId && this.cache.tvMap.has(tvdbId)) {
+      return this._hydrateRequest(this.cache.tvMap.get(tvdbId));
+    }
+    
+    // Try TMDB ID as fallback
+    if (tmdbId && this.cache.tvMap.has(tmdbId)) {
+      return this._hydrateRequest(this.cache.tvMap.get(tmdbId));
+    }
+    
+    return null;
+  }
+
+  /**
+   * Search for movie by external ID (for fallback when no request found)
+   * @param {string} tmdbId - TheMovieDB ID
+   * @param {string} imdbId - IMDB ID (optional fallback)
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchMovie(tmdbId, imdbId = null) {
+    if (tmdbId) {
+      const result = await this.client.searchMovieByTmdbId(tmdbId);
+      if (result) return result;
+    }
+    
+    if (imdbId) {
+      const result = await this.client.searchMovieByImdbId(imdbId);
+      if (result) return result;
+    }
+    
+    return null;
+  }
+
+  /**
+   * Search for TV show by external ID (for fallback when no request found)
+   * @param {string} tvdbId - TheTVDB ID
+   * @param {string} tmdbId - TheMovieDB ID (optional fallback)
+   * @returns {Promise<Object|null>} Search result object or null if not found
+   */
+  async searchTv(tvdbId, tmdbId = null) {
+    if (tvdbId) {
+      const result = await this.client.searchTvByTvdbId(tvdbId);
+      if (result) return result;
+    }
+    
+    if (tmdbId) {
+      const result = await this.client.searchTvByTmdbId(tmdbId);
+      if (result) return result;
+    }
+    
+    return null;
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {Object} Cache statistics
+   */
+  getCacheStats() {
+    return {
+      movieRequests: this.cache.movieRequests.length,
+      tvRequests: this.cache.tvRequests.length,
+      movieMapSize: this.cache.movieMap.size,
+      tvMapSize: this.cache.tvMap.size,
+      lastFetch: this.cache.lastFetch,
+      age: Date.now() - this.cache.lastFetch
+    };
+  }
+}
+
+module.exports = OmbiRetriever;

server/clients/PollingRadarrRetriever.js

@@ -37,23 +37,42 @@ class PollingRadarrRetriever extends ArrRetriever {
    * @returns {Promise<Object>} Queue object with records array
    */
   async getQueue() {
-    try {
-      // Fetch with large page size to get all items (Radarr has pagination)
-      const response = await axios.get(`${this.url}/api/v3/queue`, {
-        headers: { 'X-Api-Key': this.apiKey },
-        params: { includeMovie: true, pageSize: 1000 }
-      });
-      return response.data;
-    } catch (error) {
-      logToFile(`[PollingRadarrRetriever] ${this.id} queue error: ${error.message}`);
-      return { records: [] };
-    }
+    const instanceName = this.name;
+    let page = 1;
+    let allRecords = [];
+    let responseData = null;
+
+    do {
+      try {
+        const response = await axios.get(`${this.url}/api/v3/queue`, {
+          headers: { 'X-Api-Key': this.apiKey },
+          params: { includeMovie: true, page, pageSize: 1000 }
+        });
+        responseData = response.data;
+      } catch (error) {
+        console.error(`Radarr queue fetch failed for instance ${instanceName}:`, error.response?.data || error.message);
+        throw error;
+      }
+
+      const records = responseData.records || (Array.isArray(responseData) ? responseData : []);
+      allRecords = allRecords.concat(records);
+      page++;
+    } while (
+      (responseData.records || (Array.isArray(responseData) ? responseData : [])).length === 1000 &&
+      page <= 50
+    );
+
+    return {
+      ...responseData,
+      records: allRecords
+    };
   }
 
   /**
    * Get history from Radarr instance
    * @param {Object} options - Optional parameters for history fetch
-   * @param {number} [options.pageSize=10] - Number of records to fetch
+   * @param {number} [options.pageSize=100] - Number of records to fetch per page
+   * @param {number} [options.maxPages=1] - Maximum pages to fetch (for pagination control)
    * @param {string} [options.sortKey] - Field to sort by
    * @param {string} [options.sortDir] - Sort direction ('ascending' or 'descending')
    * @param {boolean} [options.includeMovie=true] - Include movie data
@@ -63,14 +82,21 @@ class PollingRadarrRetriever extends ArrRetriever {
   async getHistory(options = {}) {
     const {
       pageSize = 100,
+      maxPages = 1,
       sortKey,
       sortDir,
       includeMovie = true,
       startDate
     } = options;
 
-    try {
+    const instanceName = this.name;
+    let page = 1;
+    let allRecords = [];
+    let responseData = null;
+
+    do {
       const params = {
+        page,
         pageSize,
         includeMovie
       };
@@ -79,15 +105,29 @@ class PollingRadarrRetriever extends ArrRetriever {
       if (sortDir) params.sortDir = sortDir;
       if (startDate) params.startDate = startDate;
 
-      const response = await axios.get(`${this.url}/api/v3/history`, {
-        headers: { 'X-Api-Key': this.apiKey },
-        params
-      });
-      return response.data;
-    } catch (error) {
-      logToFile(`[PollingRadarrRetriever] ${this.id} history error: ${error.message}`);
-      return { records: [] };
-    }
+      try {
+        const response = await axios.get(`${this.url}/api/v3/history`, {
+          headers: { 'X-Api-Key': this.apiKey },
+          params
+        });
+        responseData = response.data;
+      } catch (error) {
+        console.error(`Radarr history fetch failed for instance ${instanceName}:`, error.response?.data || error.message);
+        throw error;
+      }
+
+      const records = responseData.records || (Array.isArray(responseData) ? responseData : []);
+      allRecords = allRecords.concat(records);
+      page++;
+    } while (
+      (responseData.records || (Array.isArray(responseData) ? responseData : [])).length === pageSize &&
+      page <= maxPages
+    );
+
+    return {
+      ...responseData,
+      records: allRecords
+    };
   }
 }
 

server/clients/PollingSonarrRetriever.js

@@ -37,23 +37,42 @@ class PollingSonarrRetriever extends ArrRetriever {
    * @returns {Promise<Object>} Queue object with records array
    */
   async getQueue() {
-    try {
-      // Fetch with large page size to get all items (Sonarr has pagination)
-      const response = await axios.get(`${this.url}/api/v3/queue`, {
-        headers: { 'X-Api-Key': this.apiKey },
-        params: { includeSeries: true, includeEpisode: true, pageSize: 1000 }
-      });
-      return response.data;
-    } catch (error) {
-      logToFile(`[PollingSonarrRetriever] ${this.id} queue error: ${error.message}`);
-      return { records: [] };
-    }
+    const instanceName = this.name;
+    let page = 1;
+    let allRecords = [];
+    let responseData = null;
+
+    do {
+      try {
+        const response = await axios.get(`${this.url}/api/v3/queue`, {
+          headers: { 'X-Api-Key': this.apiKey },
+          params: { includeSeries: true, includeEpisode: true, page, pageSize: 1000 }
+        });
+        responseData = response.data;
+      } catch (error) {
+        console.error(`Sonarr queue fetch failed for instance ${instanceName}:`, error.response?.data || error.message);
+        throw error;
+      }
+
+      const records = responseData.records || (Array.isArray(responseData) ? responseData : []);
+      allRecords = allRecords.concat(records);
+      page++;
+    } while (
+      (responseData.records || (Array.isArray(responseData) ? responseData : [])).length === 1000 &&
+      page <= 50
+    );
+
+    return {
+      ...responseData,
+      records: allRecords
+    };
   }
 
   /**
    * Get history from Sonarr instance
    * @param {Object} options - Optional parameters for history fetch
-   * @param {number} [options.pageSize=10] - Number of records to fetch
+   * @param {number} [options.pageSize=100] - Number of records to fetch per page
+   * @param {number} [options.maxPages=1] - Maximum pages to fetch (for pagination control)
    * @param {string} [options.sortKey] - Field to sort by
    * @param {string} [options.sortDir] - Sort direction ('ascending' or 'descending')
    * @param {boolean} [options.includeSeries=true] - Include series data
@@ -64,6 +83,7 @@ class PollingSonarrRetriever extends ArrRetriever {
   async getHistory(options = {}) {
     const {
       pageSize = 100,
+      maxPages = 1,
       sortKey,
       sortDir,
       includeSeries = true,
@@ -71,8 +91,14 @@ class PollingSonarrRetriever extends ArrRetriever {
       startDate
     } = options;
 
-    try {
+    const instanceName = this.name;
+    let page = 1;
+    let allRecords = [];
+    let responseData = null;
+
+    do {
       const params = {
+        page,
         pageSize,
         includeSeries,
         includeEpisode
@@ -82,15 +108,29 @@ class PollingSonarrRetriever extends ArrRetriever {
       if (sortDir) params.sortDir = sortDir;
       if (startDate) params.startDate = startDate;
 
-      const response = await axios.get(`${this.url}/api/v3/history`, {
-        headers: { 'X-Api-Key': this.apiKey },
-        params
-      });
-      return response.data;
-    } catch (error) {
-      logToFile(`[PollingSonarrRetriever] ${this.id} history error: ${error.message}`);
-      return { records: [] };
-    }
+      try {
+        const response = await axios.get(`${this.url}/api/v3/history`, {
+          headers: { 'X-Api-Key': this.apiKey },
+          params
+        });
+        responseData = response.data;
+      } catch (error) {
+        console.error(`Sonarr history fetch failed for instance ${instanceName}:`, error.response?.data || error.message);
+        throw error;
+      }
+
+      const records = responseData.records || (Array.isArray(responseData) ? responseData : []);
+      allRecords = allRecords.concat(records);
+      page++;
+    } while (
+      (responseData.records || (Array.isArray(responseData) ? responseData : [])).length === pageSize &&
+      page <= maxPages
+    );
+
+    return {
+      ...responseData,
+      records: allRecords
+    };
   }
 }
 

server/clients/QBittorrentClient.js

@@ -23,9 +23,11 @@ class QBittorrentClient extends DownloadClient {
       // Try a simple API call to verify connection
       await this.makeRequest('/api/v2/app/version');
       logToFile(`[qBittorrent:${this.name}] Connection test successful`);
+      this._clearLastError();
       return true;
     } catch (error) {
       logToFile(`[qBittorrent:${this.name}] Connection test failed: ${error.message}`);
+      this._recordLastError('testConnection', error);
       return false;
     }
   }
@@ -104,6 +106,11 @@ class QBittorrentClient extends DownloadClient {
     const response = await this.makeRequest(`/api/v2/sync/maindata?rid=${this.lastRid}`);
     const data = response.data;
 
+    if (!data) {
+      logToFile(`[qBittorrent:${this.name}] Empty response from sync/maindata`);
+      return Array.from(this.torrentMap.values());
+    }
+
     if (data.full_update) {
       // Full refresh: rebuild the entire map
       this.torrentMap.clear();
@@ -159,20 +166,32 @@ class QBittorrentClient extends DownloadClient {
       if (this.fallbackThisCycle) {
         logToFile(`[qBittorrent:${this.name}] Already fell back this cycle, using legacy`);
         const torrents = await this.getTorrentsLegacy();
+        this.torrentMap = new Map();
+        for (const torrent of torrents) {
+          this.torrentMap.set(torrent.hash, torrent);
+        }
+        this.lastRid = 0;
         return torrents.map(torrent => this.normalizeDownload(torrent));
       }
 
       const torrents = await this.getMainData();
       logToFile(`[qBittorrent:${this.name}] Sync: ${torrents.length} torrents (rid=${this.lastRid})`);
+      this._clearLastError();
       return torrents.map(torrent => this.normalizeDownload(torrent));
     } catch (error) {
       logToFile(`[qBittorrent:${this.name}] Sync failed, falling back to legacy: ${error.message}`);
       this.fallbackThisCycle = true;
       try {
         const torrents = await this.getTorrentsLegacy();
+        this.torrentMap = new Map();
+        for (const torrent of torrents) {
+          this.torrentMap.set(torrent.hash, torrent);
+        }
+        this.lastRid = 0;
         return torrents.map(torrent => this.normalizeDownload(torrent));
       } catch (fallbackError) {
         logToFile(`[qBittorrent:${this.name}] Fallback also failed: ${fallbackError.message}`);
+        this._recordLastError('getActiveDownloads', fallbackError);
         return [];
       }
     }
@@ -183,6 +202,7 @@ class QBittorrentClient extends DownloadClient {
       const response = await this.makeRequest('/api/v2/sync/maindata');
       const data = response.data;
       
+      this._clearLastError();
       return {
         serverState: data.server_state || {},
         rid: data.rid,
@@ -190,6 +210,7 @@ class QBittorrentClient extends DownloadClient {
       };
     } catch (error) {
       logToFile(`[qBittorrent:${this.name}] Error getting client status: ${error.message}`);
+      this._recordLastError('getClientStatus', error);
       return null;
     }
   }
@@ -239,6 +260,14 @@ class QBittorrentClient extends DownloadClient {
       downloaded: downloadedSize,
       speed: torrent.dlspeed,
       eta: torrent.eta < 0 || torrent.eta === 8640000 ? null : torrent.eta,
+      // Connected peer counts (Issue #64). qBittorrent exposes:
+      //   num_seeds   — connected seeds (peers we have a connection to)
+      //   num_leechs  — connected leechers (peers downloading from us)
+      //   num_complete / num_incomplete — *swarm* totals reported by tracker
+      // We expose the connected counts to stay consistent with what other
+      // clients (e.g. Transmission via peersConnected/peersSendingToUs) report.
+      seeds: torrent.num_seeds ?? 0,
+      peers: torrent.num_leechs ?? 0,
       category: torrent.category || undefined,
       tags: torrent.tags ? torrent.tags.split(',').filter(tag => tag.trim()) : [],
       savePath: torrent.content_path || torrent.save_path || undefined,

server/clients/RTorrentClient.js

@@ -35,9 +35,11 @@ class RTorrentClient extends DownloadClient {
     try {
       await this._methodCall('system.client_version');
       logToFile(`[rtorrent:${this.name}] Connection test successful`);
+      this._clearLastError();
       return true;
     } catch (error) {
       logToFile(`[rtorrent:${this.name}] Connection test failed: ${error.message}`);
+      this._recordLastError('testConnection', error);
       return false;
     }
   }
@@ -77,10 +79,31 @@ class RTorrentClient extends DownloadClient {
         'd.custom1='
       ]);
 
+      // rTorrent XML-RPC can occasionally return null/undefined or a non-array
+      // on misconfigured servers or transient errors. Guard against that here
+      // so callers always get a sane array instead of throwing on .map.
+      if (!Array.isArray(torrents)) {
+        logToFile(`[rtorrent:${this.name}] d.multicall2 returned non-array (${typeof torrents}); treating as empty`);
+        this._clearLastError();
+        return [];
+      }
+
       logToFile(`[rtorrent:${this.name}] Retrieved ${torrents.length} torrents`);
-      return torrents.map(torrent => this.normalizeDownload(torrent));
+      this._clearLastError();
+      // Filter out any individual rows that fail to normalize so a single bad
+      // record cannot poison the whole result set.
+      const normalized = [];
+      for (const torrent of torrents) {
+        try {
+          normalized.push(this.normalizeDownload(torrent));
+        } catch (err) {
+          logToFile(`[rtorrent:${this.name}] Skipping malformed torrent row: ${err.message}`);
+        }
+      }
+      return normalized;
     } catch (error) {
       logToFile(`[rtorrent:${this.name}] Error fetching torrents: ${error.message}`);
+      this._recordLastError('getActiveDownloads', error);
       return [];
     }
   }
@@ -92,31 +115,53 @@ class RTorrentClient extends DownloadClient {
         this._methodCall('throttle.global_up.rate')
       ]);
 
+      this._clearLastError();
       return {
-        globalDownRate: downRate,
-        globalUpRate: upRate
+        globalDownRate: Number.isFinite(downRate) ? downRate : 0,
+        globalUpRate: Number.isFinite(upRate) ? upRate : 0
       };
     } catch (error) {
       logToFile(`[rtorrent:${this.name}] Error getting client status: ${error.message}`);
+      this._recordLastError('getClientStatus', error);
       return null;
     }
   }
 
   normalizeDownload(torrent) {
+    // rTorrent's d.multicall2 returns an array of fields in the order requested.
+    // If a value is missing rtorrent typically returns '' or 0, but plugins and
+    // older versions can return undefined/null — coerce everything explicitly so
+    // downstream math and string ops never blow up on null/undefined.
+    if (!Array.isArray(torrent)) {
+      throw new Error('Expected torrent row to be an array');
+    }
+
     const [
-      hash,
-      name,
-      sizeBytes,
-      completedBytes,
-      downRate,
-      upRate,
-      state,
-      isActive,
-      isHashChecking,
-      directory,
-      custom1
+      hashRaw,
+      nameRaw,
+      sizeBytesRaw,
+      completedBytesRaw,
+      downRateRaw,
+      upRateRaw,
+      stateRaw,
+      isActiveRaw,
+      isHashCheckingRaw,
+      directoryRaw,
+      custom1Raw
     ] = torrent;
 
+    const hash = hashRaw ? String(hashRaw) : '';
+    const name = nameRaw ? String(nameRaw) : '';
+    const sizeBytes = Number(sizeBytesRaw) || 0;
+    const completedBytes = Number(completedBytesRaw) || 0;
+    const downRate = Number(downRateRaw) || 0;
+    const upRate = Number(upRateRaw) || 0;
+    const state = Number.isFinite(Number(stateRaw)) ? Number(stateRaw) : 0;
+    const isActive = Number.isFinite(Number(isActiveRaw)) ? Number(isActiveRaw) : 0;
+    const isHashChecking = Number.isFinite(Number(isHashCheckingRaw)) ? Number(isHashCheckingRaw) : 0;
+    const directory = directoryRaw ? String(directoryRaw) : '';
+    const custom1 = custom1Raw ? String(custom1Raw) : '';
+
     const status = this._mapStatus(state, isActive, isHashChecking, completedBytes, sizeBytes);
     const progress = sizeBytes > 0 ? Math.round((completedBytes / sizeBytes) * 100) : 0;
 
@@ -168,6 +213,11 @@ class RTorrentClient extends DownloadClient {
   }
 
   _extractArrInfo(filename) {
+    // Null-safe: getActiveDownloads passes a normalized string, but guard anyway
+    // so callers passing raw rtorrent values cannot crash this helper.
+    if (!filename || typeof filename !== 'string') {
+      return {};
+    }
     const seriesMatch = filename.match(/[-\s]S(\d{2})E(\d{2})/i);
     if (seriesMatch) {
       return { type: 'series' };

server/clients/SABnzbdClient.js

@@ -3,9 +3,27 @@ const axios = require('axios');
 const DownloadClient = require('./DownloadClient');
 const { logToFile } = require('../utils/logger');
 
+// Number of recently completed jobs to pull from SABnzbd's /api?mode=history on
+// every poll. Larger values let DownloadMatcher correlate slightly older jobs
+// with their Sonarr/Radarr queue entries at the cost of one wider HTTP
+// response per poll cycle. Configurable via the SAB_HISTORY_LIMIT environment
+// variable; defaults to 10 to match the previous hardcoded value.
+const DEFAULT_HISTORY_LIMIT = 10;
+function resolveHistoryLimit() {
+  const raw = process.env.SAB_HISTORY_LIMIT;
+  if (raw === undefined || raw === null || raw === '') return DEFAULT_HISTORY_LIMIT;
+  const parsed = parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    logToFile(`[SABnzbd] Invalid SAB_HISTORY_LIMIT='${raw}'; falling back to ${DEFAULT_HISTORY_LIMIT}`);
+    return DEFAULT_HISTORY_LIMIT;
+  }
+  return parsed;
+}
+
 class SABnzbdClient extends DownloadClient {
   constructor(instance) {
     super(instance);
+    this.historyLimit = resolveHistoryLimit();
   }
 
   getClientType() {
@@ -16,9 +34,11 @@ class SABnzbdClient extends DownloadClient {
     try {
       const response = await this.makeRequest('', { mode: 'version' });
       logToFile(`[SABnzbd:${this.name}] Connection test successful, version: ${response.data.version}`);
+      this._clearLastError();
       return true;
     } catch (error) {
       logToFile(`[SABnzbd:${this.name}] Connection test failed: ${error.message}`);
+      this._recordLastError('testConnection', error);
       return false;
     }
   }
@@ -47,32 +67,64 @@ class SABnzbdClient extends DownloadClient {
       // Get both queue and history to provide complete picture
       const [queueResponse, historyResponse] = await Promise.all([
         this.makeRequest({ mode: 'queue' }),
-        this.makeRequest({ mode: 'history', limit: 10 })
+        this.makeRequest({ mode: 'history', limit: this.historyLimit })
       ]);
 
       const queueData = queueResponse.data;
       const historyData = historyResponse.data;
 
+      // Extract client status directly from the fetched queue data instead of making a redundant HTTP request
+      let clientStatus = null;
+      if (queueData && queueData.queue) {
+        const q = queueData.queue;
+        clientStatus = {
+          status: q.status,
+          speed: q.speed,
+          kbpersec: q.kbpersec,
+          sizeleft: q.sizeleft,
+          mbleft: q.mbleft,
+          mb: q.mb,
+          diskspace1: q.diskspace1,
+          diskspace2: q.diskspace2,
+          loadavg: q.loadavg,
+          pause_int: q.pause_int
+        };
+      }
+
       const downloads = [];
 
       // Process active queue items
       if (queueData.queue && queueData.queue.slots) {
+        const kbpersec = (queueData.queue && queueData.queue.kbpersec) || (clientStatus && clientStatus.kbpersec) || 0;
+        const globalSpeed = parseFloat(kbpersec) * 1024;
+
+        logToFile(`[SABnzbd:${this.name}] Global Speed: ${globalSpeed}, Client status: ${clientStatus ? JSON.stringify({ kbpersec: clientStatus.kbpersec }) : 'none'}`);
+
         for (const slot of queueData.queue.slots) {
-          downloads.push(this.normalizeDownload(slot, 'queue'));
+          let slotSpeed = 0;
+          if (slot.status === 'Downloading') {
+            slotSpeed = globalSpeed;
+          } else if (slot.status === 'Paused' && slot.kbpersec && parseFloat(slot.kbpersec) > 0) {
+            slotSpeed = globalSpeed;
+          }
+          logToFile(`[SABnzbd:${this.name}] Slot ${slot.nzo_id} status ${slot.status}, speed ${slotSpeed}`);
+          downloads.push(this.normalizeDownload(slot, 'queue', slotSpeed));
         }
       }
 
       // Process recent history items (last 10)
       if (historyData.history && historyData.history.slots) {
         for (const slot of historyData.history.slots) {
-          downloads.push(this.normalizeDownload(slot, 'history'));
+          downloads.push(this.normalizeDownload(slot, 'history', 0));
         }
       }
 
-      logToFile(`[SABnzbd:${this.name}] Retrieved ${downloads.length} downloads`);
+      logToFile(`[SABnzbd:${this.name}] Retrieved ${downloads.length} downloads (historyLimit=${this.historyLimit})`);
+      this._clearLastError();
       return downloads;
     } catch (error) {
       logToFile(`[SABnzbd:${this.name}] Error fetching downloads: ${error.message}`);
+      this._recordLastError('getActiveDownloads', error);
       return [];
     }
   }
@@ -82,8 +134,12 @@ class SABnzbdClient extends DownloadClient {
       const response = await this.makeRequest({ mode: 'queue' });
       const queueData = response.data.queue;
       
-      if (!queueData) return null;
+      if (!queueData) {
+        this._clearLastError();
+        return null;
+      }
 
+      this._clearLastError();
       return {
         status: queueData.status,
         speed: queueData.speed,
@@ -98,13 +154,15 @@ class SABnzbdClient extends DownloadClient {
       };
     } catch (error) {
       logToFile(`[SABnzbd:${this.name}] Error getting client status: ${error.message}`);
+      this._recordLastError('getClientStatus', error);
       return null;
     }
   }
 
-  normalizeDownload(slot, source) {
+  normalizeDownload(slot, source, speed) {
     const isHistory = source === 'history';
-    
+    const finalSpeed = speed !== undefined ? speed : (slot.kbpersec ? parseFloat(slot.kbpersec) * 1024 : 0);
+
     // Map SABnzbd statuses to normalized status
     const statusMap = {
       'Downloading': 'Downloading',
@@ -126,10 +184,15 @@ class SABnzbdClient extends DownloadClient {
     let downloaded = 0;
     let size = 0;
 
-    if (slot.mb && slot.mbleft !== undefined) {
-      size = slot.mb * 1024 * 1024; // Convert MB to bytes
-      downloaded = (slot.mb - slot.mbleft) * 1024 * 1024;
-      progress = slot.mb > 0 ? ((slot.mb - slot.mbleft) / slot.mb) * 100 : 0;
+    const hasMb = slot.mb !== undefined && slot.mb !== null;
+    const hasMbLeft = slot.mbleft !== undefined && slot.mbleft !== null;
+    const mbValue = hasMb ? parseFloat(slot.mb) : 0;
+    const mbLeftValue = hasMbLeft ? parseFloat(slot.mbleft) : 0;
+
+    if (hasMb && hasMbLeft && mbValue !== 0) {
+      size = mbValue * 1024 * 1024; // Convert MB to bytes
+      downloaded = (mbValue - mbLeftValue) * 1024 * 1024;
+      progress = mbValue > 0 ? ((mbValue - mbLeftValue) / mbValue) * 100 : 0;
     } else if (slot.size) {
       // Try to parse size string (e.g., "1.5 GB")
       const sizeMatch = slot.size.match(/^([\d.]+)\s*(\w+)$/i);
@@ -164,7 +227,7 @@ class SABnzbdClient extends DownloadClient {
       progress: Math.round(progress),
       size: Math.round(size),
       downloaded: Math.round(downloaded),
-      speed: slot.kbpersec ? slot.kbpersec * 1024 : 0, // Convert KB/s to bytes/s
+      speed: finalSpeed,
       eta: this.calculateEta(slot.timeleft || slot.eta),
       category: slot.cat || undefined,
       tags: slot.labels ? (Array.isArray(slot.labels) ? slot.labels : slot.labels.split(',')).filter(tag => tag && tag.trim()) : [],

server/clients/TransmissionClient.js

@@ -18,9 +18,11 @@ class TransmissionClient extends DownloadClient {
     try {
       await this.makeRequest('session-get');
       logToFile(`[Transmission:${this.name}] Connection test successful`);
+      this._clearLastError();
       return true;
     } catch (error) {
       logToFile(`[Transmission:${this.name}] Connection test failed: ${error.message}`);
+      this._recordLastError('testConnection', error);
       return false;
     }
   }
@@ -80,10 +82,11 @@ class TransmissionClient extends DownloadClient {
 
       const torrents = response.data.arguments.torrents || [];
       logToFile(`[Transmission:${this.name}] Retrieved ${torrents.length} torrents`);
-      
+      this._clearLastError();
       return torrents.map(torrent => this.normalizeDownload(torrent));
     } catch (error) {
       logToFile(`[Transmission:${this.name}] Error fetching torrents: ${error.message}`);
+      this._recordLastError('getActiveDownloads', error);
       return [];
     }
   }
@@ -93,12 +96,14 @@ class TransmissionClient extends DownloadClient {
       const response = await this.makeRequest('session-get');
       const sessionStats = await this.makeRequest('session-stats');
       
+      this._clearLastError();
       return {
         session: response.data.arguments,
         stats: sessionStats.data.arguments
       };
     } catch (error) {
       logToFile(`[Transmission:${this.name}] Error getting client status: ${error.message}`);
+      this._recordLastError('getClientStatus', error);
       return null;
     }
   }
@@ -113,7 +118,11 @@ class TransmissionClient extends DownloadClient {
       4: 'Downloading',  // TORRENT_DOWNLOAD
       5: 'Queued',       // TORRENT_SEED_WAIT
       6: 'Seeding',      // TORRENT_SEED
-      7: 'Unknown'       // TORRENT_IS_CHECKING (alias for 2)
+      // Status code 7 is undocumented in the Transmission RPC spec (which
+      // formally defines only 0–6). The legacy alias "TORRENT_IS_CHECKING"
+      // (a duplicate of code 2) is the best-effort interpretation; map it to
+      // `Checking` so it is rendered usefully rather than as `Unknown`.
+      7: 'Checking'      // TORRENT_IS_CHECKING (undocumented; treated as code 2)
     };
 
     const status = statusMap[torrent.status] || 'Unknown';
@@ -160,8 +169,12 @@ class TransmissionClient extends DownloadClient {
   }
 
   extractArrInfo(filename) {
-    // Similar to SABnzbdClient, try to extract Sonarr/Radarr info
-    
+    // arrQueueId cannot be extracted from filename alone; *arr exposes that
+    // identifier only via its queue API. The reliable cross-client matching
+    // path is hash-based and lives in `DownloadMatcher.matchTorrents()` (see
+    // Issue #65), which keys on `torrent.hashString` for Transmission.
+    // This heuristic remains only to provide a coarse `type` hint.
+
     // Look for patterns like "Series Name - S01E02 - Episode Title"
     const seriesMatch = filename.match(/[-\s]S(\d{2})E(\d{2})/i);
     if (seriesMatch) {
@@ -176,6 +189,39 @@ class TransmissionClient extends DownloadClient {
 
     return {};
   }
+
+  /**
+   * Start (resume) one or more torrents. `id` is the Transmission internal
+   * numeric id or a hashString; the RPC accepts either.
+   * @param {number|string|Array<number|string>} id
+   */
+  async startTorrent(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await this.makeRequest('torrent-start', { ids });
+    logToFile(`[Transmission:${this.name}] Started torrent(s): ${ids.join(', ')}`);
+  }
+
+  /**
+   * Stop (pause) one or more torrents.
+   * @param {number|string|Array<number|string>} id
+   */
+  async stopTorrent(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    await this.makeRequest('torrent-stop', { ids });
+    logToFile(`[Transmission:${this.name}] Stopped torrent(s): ${ids.join(', ')}`);
+  }
+
+  /**
+   * Remove one or more torrents. When `deleteData` is true the local files
+   * are also deleted from disk (Transmission's `delete-local-data`).
+   * @param {number|string|Array<number|string>} id
+   * @param {boolean} [deleteData=false]
+   */
+  async removeTorrent(id, deleteData = false) {
+    const ids = Array.isArray(id) ? id : [id];
+    await this.makeRequest('torrent-remove', { ids, 'delete-local-data': !!deleteData });
+    logToFile(`[Transmission:${this.name}] Removed torrent(s): ${ids.join(', ')} (deleteData=${!!deleteData})`);
+  }
 }
 
 module.exports = TransmissionClient;

server/index.js

@@ -8,8 +8,13 @@ const crypto = require('crypto');
 const fs = require('fs');
 const http = require('http');
 const https = require('https');
+const swaggerUi = require('swagger-ui-express');
+const swaggerJsdoc = require('swagger-jsdoc');
+const YAML = require('yamljs');
 require('dotenv').config();
 require('./utils/loadSecrets')();
+const logCapture = require('./utils/logCapture');
+logCapture.init();
 const { version } = require('../package.json');
 
 // Setup logging with levels
@@ -77,17 +82,9 @@ console.error = function(...args) {
   logFile.write(`[${new Date().toISOString()}] ERROR: ${message}\n`);
 };
 
-const sabnzbdRoutes = require('./routes/sabnzbd');
-const sonarrRoutes = require('./routes/sonarr');
-const radarrRoutes = require('./routes/radarr');
-const embyRoutes = require('./routes/emby');
-const dashboardRoutes = require('./routes/dashboard');
-const historyRoutes = require('./routes/history');
-const authRoutes = require('./routes/auth');
-const webhookRoutes = require('./routes/webhook');
-const verifyCsrf = require('./middleware/verifyCsrf');
 const { startPoller, POLL_INTERVAL, POLLING_ENABLED } = require('./utils/poller');
 const { validateInstanceUrl } = require('./utils/config');
+const { createApp } = require('./app');
 
 // ---------------------------------------------------------------------------
 // Startup environment validation
@@ -109,173 +106,10 @@ if (process.env.EMBY_URL) {
   validateInstanceUrl(process.env.EMBY_URL, 'EMBY_URL');
 }
 
-const app = express();
+const app = createApp();
 const PORT = process.env.PORT || 3001;
-
-// Resolve TLS_ENABLED early — used in Helmet CSP and server startup
 const TLS_ENABLED = (process.env.TLS_ENABLED || 'true').toLowerCase() !== 'false';
 
-// ---------------------------------------------------------------------------
-// Trust proxy — required when behind Nginx/Caddy/Traefik so that
-// req.ip reflects the real client IP (not 127.0.0.1) and
-// req.secure is true when the upstream TLS is terminated by the proxy.
-// Set TRUST_PROXY=1 (or a specific IP/CIDR) via env.
-// ---------------------------------------------------------------------------
-if (process.env.TRUST_PROXY) {
-  const trustValue = /^\d+$/.test(process.env.TRUST_PROXY)
-    ? parseInt(process.env.TRUST_PROXY, 10)
-    : process.env.TRUST_PROXY;
-  app.set('trust proxy', trustValue);
-}
-
-// ---------------------------------------------------------------------------
-// Helmet v7 — security response headers
-// CSP uses a per-request nonce injected into index.html so inline scripts
-// and styles are allowed only with a valid nonce, not blanket unsafe-inline.
-// ---------------------------------------------------------------------------
-app.use((req, res, next) => {
-  // Generate a fresh nonce for every request
-  res.locals.cspNonce = crypto.randomBytes(16).toString('base64');
-  next();
-});
-
-app.use((req, res, next) => {
-  helmet({
-    contentSecurityPolicy: {
-      directives: {
-        defaultSrc: ["'self'"],
-        scriptSrc: ["'self'", (req, res) => `'nonce-${res.locals.cspNonce}'`],
-        styleSrc: ["'self'", (req, res) => `'nonce-${res.locals.cspNonce}'`],
-        imgSrc: ["'self'", 'data:', 'blob:'],
-        fontSrc: ["'self'", 'data:'],
-        connectSrc: ["'self'"],
-        objectSrc: ["'none'"],
-        baseUri: ["'self'"],
-        frameAncestors: ["'none'"],
-        formAction: ["'self'"],
-        upgradeInsecureRequests: (process.env.TRUST_PROXY || TLS_ENABLED) ? [] : null
-      }
-    },
-    hsts: {
-      maxAge: 31536000,       // 1 year
-      includeSubDomains: true,
-      preload: true
-    },
-    referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
-    crossOriginEmbedderPolicy: false // not needed for this SPA
-  })(req, res, next);
-});
-
-// Permissions-Policy — disable powerful browser features not needed by the app
-app.use((req, res, next) => {
-  res.setHeader(
-    'Permissions-Policy',
-    'camera=(), microphone=(), geolocation=(), payment=(), usb=()'
-  );
-  next();
-});
-
-// ---------------------------------------------------------------------------
-// General API rate limiter — applies to all /api/* routes
-// More specific limiters (e.g. login) apply on top of this.
-// ---------------------------------------------------------------------------
-const apiLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000,   // 15 minutes
-  max: 300,                    // 300 requests per IP per window (generous for polling)
-  standardHeaders: true,
-  legacyHeaders: false,
-  message: { error: 'Too many requests, please try again later' }
-});
-
-// ---------------------------------------------------------------------------
-// Body parsing & cookies
-// ---------------------------------------------------------------------------
-app.use(cookieParser(cookieSecret || undefined));
-app.use(express.json({ limit: '64kb' })); // prevent oversized JSON payloads
-
-// ---------------------------------------------------------------------------
-// Health / readiness endpoints (no auth, no rate-limit)
-// Used by Docker HEALTHCHECK and orchestrators.
-// ---------------------------------------------------------------------------
-app.get('/health', (req, res) => {
-  res.json({ status: 'ok', uptime: process.uptime(), version });
-});
-
-app.get('/ready', (req, res) => {
-  // Confirm critical config is present
-  const ready = !!(process.env.EMBY_URL);
-  if (ready) {
-    res.json({ status: 'ready' });
-  } else {
-    res.status(503).json({ status: 'not ready', reason: 'EMBY_URL not configured' });
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Static files — served before API routes
-// index.html is served manually so we can inject the CSP nonce
-// ---------------------------------------------------------------------------
-const PUBLIC_DIR = path.join(__dirname, '../public');
-const INDEX_HTML = path.join(PUBLIC_DIR, 'index.html');
-
-// Serve all static assets (js, css, images, icons) except index.html.
-// JS and CSS get no-cache so browsers revalidate on every load (ETag still
-// avoids re-downloading unchanged files; only a deploy changes the ETag).
-app.use(express.static(PUBLIC_DIR, {
-  index: false,
-  setHeaders(res, filePath) {
-    if (filePath.endsWith('.js') || filePath.endsWith('.css')) {
-      res.setHeader('Cache-Control', 'no-cache');
-    }
-  }
-}));
-
-// Serve index.html with CSP nonce injected into <script> tags
-function serveIndex(req, res) {
-  fs.readFile(INDEX_HTML, 'utf8', (err, html) => {
-    if (err) return res.status(500).send('Internal Server Error');
-    const nonce = res.locals.cspNonce;
-    // Only inject nonce into <script> tags — style-src 'self' already permits
-    // same-origin <link rel=stylesheet> without a nonce, and injecting a nonce
-    // onto <link> breaks mobile browsers / caching proxies (stale HTML carries
-    // the old nonce which no longer matches the per-request CSP header).
-    const patched = html
-      .replace(/<script([^>]*)>/gi, `<script nonce="${nonce}"$1>`);
-    res.setHeader('Content-Type', 'text/html; charset=utf-8');
-    res.send(patched);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// API routes (rate-limited; auth routes exempt CSRF for login/csrf endpoints)
-// CSRF protection applies to all state-changing /api/* requests except
-// /api/auth/login (pre-auth) and /api/auth/csrf (issues the token).
-// ---------------------------------------------------------------------------
-app.use('/api', apiLimiter);
-app.use('/api/auth', authRoutes);
-app.use('/api/webhook', webhookRoutes);
-
-// All routes below this point require CSRF validation on mutating methods
-app.use('/api', verifyCsrf);
-app.use('/api/sabnzbd', sabnzbdRoutes);
-app.use('/api/sonarr', sonarrRoutes);
-app.use('/api/radarr', radarrRoutes);
-app.use('/api/emby', embyRoutes);
-app.use('/api/dashboard', dashboardRoutes);
-app.use('/api/history', historyRoutes);
-
-// SPA catch-all — serve index.html for any unmatched path
-app.get('*', serveIndex);
-
-// ---------------------------------------------------------------------------
-// Global error handler — never leak stack traces to clients
-// ---------------------------------------------------------------------------
-// eslint-disable-next-line no-unused-vars
-app.use((err, req, res, next) => {
-  console.error('[Server] Unhandled error:', err.message);
-  res.status(500).json({ error: 'Internal server error' });
-});
-
 // ---------------------------------------------------------------------------
 // TLS / HTTPS support
 // Set TLS_CERT and TLS_KEY to paths of your certificate and private key.

server/middleware/logStreamAuth.js

@@ -0,0 +1,156 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const axios = require('axios');
+const crypto = require('crypto');
+const ipaddr = require('ipaddr.js');
+
+function getEmbyUrl() {
+  return process.env.EMBY_URL;
+}
+
+function isIpAllowed(clientIp, allowedSubnetsStr) {
+  if (!allowedSubnetsStr) return true;
+  try {
+    const clientIpParsed = ipaddr.parse(clientIp);
+    const subnets = allowedSubnetsStr.split(',').map(s => s.trim()).filter(Boolean);
+
+    for (const subnet of subnets) {
+      let rangeStr = subnet;
+      let bits = null;
+      if (subnet.includes('/')) {
+        const parts = subnet.split('/');
+        rangeStr = parts[0];
+        bits = parseInt(parts[1], 10);
+      }
+
+      const rangeIpParsed = ipaddr.parse(rangeStr);
+
+      if (bits === null) {
+        // Exact IP match
+        if (clientIpParsed.toString() === rangeIpParsed.toString()) {
+          return true;
+        }
+        // Handle IPv4 mapped IPv6 address case
+        if (clientIpParsed.kind() === 'ipv6' && clientIpParsed.isIPv4MappedAddress() && rangeIpParsed.kind() === 'ipv4') {
+          if (clientIpParsed.toIPv4Address().toString() === rangeIpParsed.toString()) {
+            return true;
+          }
+        }
+        continue;
+      }
+
+      // Match with subnet bits
+      if (clientIpParsed.kind() === rangeIpParsed.kind()) {
+        if (clientIpParsed.match(rangeIpParsed, bits)) {
+          return true;
+        }
+      } else if (clientIpParsed.kind() === 'ipv6' && clientIpParsed.isIPv4MappedAddress() && rangeIpParsed.kind() === 'ipv4') {
+        // Handle IPv4 mapped IPv6 address case matching IPv4 range
+        if (clientIpParsed.toIPv4Address().match(rangeIpParsed, bits)) {
+          return true;
+        }
+      }
+    }
+  } catch (err) {
+    console.error(`[logStreamAuth] IP parsing error for IP ${clientIp}:`, err.message);
+  }
+  return false;
+}
+
+async function logStreamAuth(req, res, next) {
+  // 1. Subnet IP Filtering (First Priority)
+  const allowedSubnets = process.env.LOG_ALLOW_SUBNETS;
+  if (allowedSubnets && !isIpAllowed(req.ip, allowedSubnets)) {
+    console.warn(`[logStreamAuth] Access denied from unauthorized IP: ${req.ip}`);
+    return res.status(403).json({ error: `Access denied from IP: ${req.ip}` });
+  }
+
+  // 2. Webhook Secret Bypass (High Priority)
+  const secretHeader = req.headers['x-webhook-secret'];
+  const configuredSecret = process.env.SOFARR_WEBHOOK_SECRET;
+  if (configuredSecret && secretHeader === configuredSecret) {
+    return next();
+  }
+
+  // 3. Session Cookie
+  const signed = !!process.env.COOKIE_SECRET;
+  const rawCookie = signed ? req.signedCookies.emby_user : req.cookies.emby_user;
+  if (rawCookie && rawCookie !== false) {
+    try {
+      const u = JSON.parse(rawCookie);
+      if (u && typeof u.id === 'string' && u.id && u.isAdmin === true) {
+        req.user = u;
+        return next();
+      }
+    } catch {
+      // Ignore JSON parse errors, fallback to basic auth
+    }
+  }
+
+  // 4. Basic Authentication Fallback
+  const authHeader = req.headers.authorization;
+  if (authHeader && authHeader.startsWith('Basic ')) {
+    try {
+      const credentialsBase64 = authHeader.substring(6);
+      const credentialsStr = Buffer.from(credentialsBase64, 'base64').toString('utf8');
+      const colonIdx = credentialsStr.indexOf(':');
+
+      if (colonIdx !== -1) {
+        const username = credentialsStr.substring(0, colonIdx).trim();
+        const password = credentialsStr.substring(colonIdx + 1);
+
+        if (username && password) {
+          const embyUrl = getEmbyUrl();
+          if (!embyUrl) {
+            console.error('[logStreamAuth] Emby auth fallback failed: EMBY_URL is not configured');
+            res.setHeader('WWW-Authenticate', 'Basic realm="sofarr log stream debug"');
+            return res.status(401).json({ error: 'Authentication service unavailable' });
+          }
+
+          // Authenticate with Emby using stable DeviceId derived from username
+          const stableDeviceId = 'sofarr-' + crypto.createHash('sha256').update(username.toLowerCase()).digest('hex').slice(0, 16);
+          
+          console.log(`[logStreamAuth] Attempting Basic Auth login for: ${username}`);
+          const authResponse = await axios.post(`${embyUrl}/Users/authenticatebyname`, {
+            Username: username,
+            Pw: password
+          }, {
+            headers: {
+              'X-Emby-Authorization': `MediaBrowser Client="sofarr", Device="sofarr", DeviceId="${stableDeviceId}", Version="1.0.0"`
+            },
+            timeout: 5000
+          });
+
+          const authData = authResponse.data;
+          const userId = authData.User.Id || authData.User.id;
+
+          // Fetch detailed profile to verify administrator status
+          const userResponse = await axios.get(`${embyUrl}/Users/${userId}`, {
+            headers: {
+              'X-MediaBrowser-Token': authData.AccessToken
+            },
+            timeout: 5000
+          });
+
+          const user = userResponse.data;
+          const isAdmin = !!(user.Policy && user.Policy.IsAdministrator);
+
+          if (isAdmin) {
+            console.log(`[logStreamAuth] Basic Auth successful for administrator: ${user.Name}`);
+            req.user = { id: user.Id, name: user.Name, isAdmin: true };
+            return next();
+          } else {
+            console.warn(`[logStreamAuth] Basic Auth rejected: user ${user.Name} is not an administrator`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error('[logStreamAuth] Emby authentication error:', err.message);
+    }
+  }
+
+  // 5. Unauthorized / Access Denied
+  res.setHeader('WWW-Authenticate', 'Basic realm="sofarr log stream debug"');
+  return res.status(401).json({ error: 'Unauthorized' });
+}
+
+module.exports = logStreamAuth;

server/middleware/verifyCsrf.js

@@ -26,13 +26,14 @@ function verifyCsrf(req, res, next) {
     return res.status(403).json({ error: 'CSRF token missing' });
   }
 
-  // Constant-time comparison to prevent timing attacks
-  if (cookieToken.length !== headerToken.length) {
+  const a = Buffer.from(cookieToken);
+  const b = Buffer.from(headerToken);
+
+  // Constant-time comparison of underlying buffer lengths to prevent timing attacks
+  if (a.length !== b.length) {
     return res.status(403).json({ error: 'CSRF token invalid' });
   }
 
-  const a = Buffer.from(cookieToken);
-  const b = Buffer.from(headerToken);
   if (!require('crypto').timingSafeEqual(a, b)) {
     return res.status(403).json({ error: 'CSRF token invalid' });
   }

server/routes/auth.js

@@ -24,7 +24,159 @@ const loginLimiter = rateLimit({
   message: { success: false, error: 'Too many login attempts, please try again later' }
 });
 
-// Authenticate user with Emby
+/**
+ * @openapi
+ * /api/auth/login:
+ *   post:
+ *     tags: [Auth]
+ *     summary: Authenticate with Emby/Jellyfin
+ *     description: |
+ *       Authenticates a user against Emby/Jellyfin and sets session cookies.
+ *
+ *       **Rate Limiting:** 10 failed attempts per 15 minutes per IP (successful attempts don't count).
+ *
+ *       **Authentication Flow:**
+ *       1. Send username and password in request body
+ *       2. Server validates credentials with Emby/Jellyfin
+ *       3. Server sets httpOnly signed cookie `emby_user` containing {id, name, isAdmin}
+ *       4. Server sets `csrf_token` cookie (readable by JS for double-submit pattern)
+ *       5. Response includes user data and CSRF token
+ *
+ *       **Cookie Details:**
+ *       - `emby_user`: httpOnly, signed, sameSite=strict. Persistent if rememberMe=true (30 days), otherwise session cookie.
+ *       - `csrf_token`: httpOnly=false (JS-readable), sameSite=strict. Used for state-changing requests.
+ *
+ *       **Security Notes:**
+ *       - Password must be 1-256 characters
+ *       - Username must be 1-128 characters
+ *       - Server rejects with 400 if input validation fails
+ *       - Server rejects with 401 if Emby authentication fails
+ *
+ *       **x-integration-notes:** After successful login, subsequent requests must:
+ *       - Send the emby_user cookie (automatically by browser)
+ *       - Send the X-CSRF-Token header (from csrf_token cookie) for POST/PUT/PATCH/DELETE requests
+ *       - Use credentials: 'include' in fetch/axios to send cookies
+ *     security: []
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - username
+ *               - password
+ *             properties:
+ *               username:
+ *                 type: string
+ *                 minLength: 1
+ *                 maxLength: 128
+ *                 description: Emby/Jellyfin username
+ *                 example: "john"
+ *               password:
+ *                 type: string
+ *                 minLength: 1
+ *                 maxLength: 256
+ *                 description: Emby/Jellyfin password
+ *                 example: "password123"
+ *               rememberMe:
+ *                 type: boolean
+ *                 description: If true, cookie persists for 30 days; otherwise session cookie
+ *                 example: false
+ *           example:
+ *             username: "john"
+ *             password: "password123"
+ *             rememberMe: false
+ *     responses:
+ *       '200':
+ *         description: Login successful
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 user:
+ *                   type: object
+ *                   properties:
+ *                     id:
+ *                       type: string
+ *                       description: Emby user ID
+ *                       example: "abc123def456"
+ *                     name:
+ *                       type: string
+ *                       description: Display name
+ *                       example: "John Doe"
+ *                     isAdmin:
+ *                       type: boolean
+ *                       description: Admin flag
+ *                       example: false
+ *                 csrfToken:
+ *                   type: string
+ *                   description: CSRF token for state-changing requests
+ *                   example: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+ *             example:
+ *               success: true
+ *               user:
+ *                 id: "abc123def456"
+ *                 name: "John Doe"
+ *                 isAdmin: false
+ *               csrfToken: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+ *       '400':
+ *         description: Invalid input (username or password fails validation)
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               success: false
+ *               error: "Invalid username"
+ *       '401':
+ *         description: Invalid credentials (Emby authentication failed)
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               success: false
+ *               error: "Invalid username or password"
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           curl -X POST http://localhost:3001/api/auth/login \
+ *             -H "Content-Type: application/json" \
+ *             -c cookies.txt \
+ *             -d '{"username":"john","password":"password123"}'
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const response = await fetch('http://localhost:3001/api/auth/login', {
+ *             method: 'POST',
+ *             headers: { 'Content-Type': 'application/json' },
+ *             credentials: 'include',
+ *             body: JSON.stringify({ username: 'john', password: 'password123' })
+ *           });
+ *           const data = await response.json();
+ *           console.log(data.csrfToken); // Save this for subsequent requests
+ *       - lang: TypeScript
+ *         label: TypeScript
+ *         source: |
+ *           interface LoginResponse {
+ *             success: boolean;
+ *             user: { id: string; name: string; isAdmin: boolean };
+ *             csrfToken: string;
+ *           }
+ *           const response = await fetch('http://localhost:3001/api/auth/login', {
+ *             method: 'POST',
+ *             headers: { 'Content-Type': 'application/json' },
+ *             credentials: 'include',
+ *             body: JSON.stringify({ username: 'john', password: 'password123' })
+ *           });
+ *           const data: LoginResponse = await response.json();
+ */
 router.post('/login', loginLimiter, async (req, res) => {
   try {
     const { username, password, rememberMe } = req.body;
@@ -129,7 +281,80 @@ function parseSessionCookie(req) {
   }
 }
 
-// Get current authenticated user
+/**
+ * @openapi
+ * /api/auth/me:
+ *   get:
+ *     tags: [Auth]
+ *     summary: Get current authenticated user
+ *     description: |
+ *       Returns the currently authenticated user from the session cookie.
+ *
+ *       **Authentication:** Requires valid `emby_user` cookie.
+ *
+ *       **Response:**
+ *       - If authenticated: returns user data (id, name, isAdmin)
+ *       - If not authenticated: returns authenticated: false
+ *
+ *       **Use Case:** Check if user is logged in and get user details without re-authenticating.
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: User data (authenticated or not)
+ *         content:
+ *           application/json:
+ *             schema:
+ *               oneOf:
+ *                 - type: object
+ *                   properties:
+ *                     authenticated:
+ *                       type: boolean
+ *                       example: true
+ *                     user:
+ *                       type: object
+ *                       properties:
+ *                         id:
+ *                           type: string
+ *                           example: "abc123def456"
+ *                         name:
+ *                           type: string
+ *                           example: "John Doe"
+ *                         isAdmin:
+ *                           type: boolean
+ *                           example: false
+ *                 - type: object
+ *                   properties:
+ *                     authenticated:
+ *                       type: boolean
+ *                       example: false
+ *             examples:
+ *               authenticated:
+ *                 authenticated: true
+ *                 user:
+ *                   id: "abc123def456"
+ *                   name: "John Doe"
+ *                   isAdmin: false
+ *               notAuthenticated:
+ *                 authenticated: false
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           curl -X GET http://localhost:3001/api/auth/me \
+ *             -b cookies.txt
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const response = await fetch('http://localhost:3001/api/auth/me', {
+ *             method: 'GET',
+ *             credentials: 'include'
+ *           });
+ *           const data = await response.json();
+ *           if (data.authenticated) {
+ *             console.log('User:', data.user.name);
+ *           }
+ */
 router.get('/me', (req, res) => {
   const user = parseSessionCookie(req);
   if (!user) return res.json({ authenticated: false });
@@ -139,8 +364,57 @@ router.get('/me', (req, res) => {
   });
 });
 
-// CSRF token refresh — lets the SPA get a new token without re-logging-in
-// (e.g. after a page reload where the JS variable was lost)
+/**
+ * @openapi
+ * /api/auth/csrf:
+ *   get:
+ *     tags: [Auth]
+ *     summary: Refresh CSRF token
+ *     description: |
+ *       Returns a fresh CSRF token and sets it as a cookie.
+ *
+ *       **Purpose:** Lets the SPA get a new CSRF token without re-authenticating
+ *       (e.g., after a page reload where the JS variable containing the token was lost).
+ *
+ *       **Authentication:** No authentication required (CSRF tokens are issued to all clients).
+ *
+ *       **Cookie Details:**
+ *       - Sets `csrf_token` cookie (httpOnly=false, readable by JS)
+ *       - sameSite=strict, secure when TRUST_PROXY is set
+ *
+ *       **Use Case:** Call this endpoint when your application needs a fresh CSRF token
+ *       for state-changing requests (POST/PUT/PATCH/DELETE).
+ *     security: []
+ *     responses:
+ *       '200':
+ *         description: CSRF token
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 csrfToken:
+ *                   type: string
+ *                   description: Fresh CSRF token for state-changing requests
+ *                   example: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+ *             example:
+ *               csrfToken: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           curl -X GET http://localhost:3001/api/auth/csrf \
+ *             -c cookies.txt
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const response = await fetch('http://localhost:3001/api/auth/csrf', {
+ *             method: 'GET',
+ *             credentials: 'include'
+ *           });
+ *           const data = await response.json();
+ *           const csrfToken = data.csrfToken; // Use this in X-CSRF-Token header
+ */
 router.get('/csrf', (req, res) => {
   const csrfToken = crypto.randomBytes(32).toString('hex');
   res.cookie('csrf_token', csrfToken, {
@@ -152,7 +426,84 @@ router.get('/csrf', (req, res) => {
   res.json({ csrfToken });
 });
 
-// Logout
+/**
+ * @openapi
+ * /api/auth/logout:
+ *   post:
+ *     tags: [Auth]
+ *     summary: Logout
+ *     description: |
+ *       Clears session cookies and revokes the Emby/Jellyfin access token.
+ *
+ *       **Authentication:** Requires valid `emby_user` cookie and `X-CSRF-Token` header.
+ *
+ *       **Actions Performed:**
+ *       1. Revokes the Emby/Jellyfin access token on the Emby server
+ *       2. Clears the server-side token store
+ *       3. Clears the `emby_user` cookie
+ *       4. Clears the `csrf_token` cookie
+ *
+ *       **Error Handling:** If Emby token revocation fails, the logout still succeeds
+ *       (cookies are cleared) but a warning is logged.
+ *
+ *       **x-integration-notes:** After logout, the client must discard the CSRF token
+ *       and not attempt further authenticated requests until re-authenticating.
+ *     security:
+ *       - CookieAuth: []
+ *       - CsrfToken: []
+ *     responses:
+ *       '200':
+ *         description: Logout successful
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *             example:
+ *               success: true
+ *       '401':
+ *         description: Not authenticated (no valid session)
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '403':
+ *         description: CSRF token missing or invalid
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           # Get CSRF token first
+ *           CSRF_TOKEN=$(curl -s -c cookies.txt http://localhost:3001/api/auth/csrf | jq -r .csrfToken)
+ *           # Logout
+ *           curl -X POST http://localhost:3001/api/auth/logout \
+ *             -H "X-CSRF-Token: $CSRF_TOKEN" \
+ *             -b cookies.txt \
+ *             -c cookies.txt
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const csrfResponse = await fetch('http://localhost:3001/api/auth/csrf', {
+ *             method: 'GET',
+ *             credentials: 'include'
+ *           });
+ *           const { csrfToken } = await csrfResponse.json();
+ *
+ *           const response = await fetch('http://localhost:3001/api/auth/logout', {
+ *             method: 'POST',
+ *             headers: { 'X-CSRF-Token': csrfToken },
+ *             credentials: 'include'
+ *           });
+ *           const data = await response.json();
+ *           console.log(data.success); // true
+ */
 router.post('/logout', async (req, res) => {
   const user = parseSessionCookie(req);
   if (user) {

server/routes/debug.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const express = require('express');
+const router = express.Router();
+const logStreamAuth = require('../middleware/logStreamAuth');
+const {
+  logEmitter,
+  logBuffer,
+  clientLogBuffer,
+  ingestClientLogs
+} = require('../utils/logCapture');
+
+// Public status check (no auth, no 403 block, returns standard config state)
+router.get('/status', (req, res) => {
+  res.json({ enabled: process.env.ENABLE_LOG_STREAM === 'true' });
+});
+
+// Global toggle check
+router.use((req, res, next) => {
+  if (process.env.ENABLE_LOG_STREAM !== 'true') {
+    return res.status(403).json({ error: 'Log streaming feature is disabled' });
+  }
+  next();
+});
+
+// Enforce subnet and authentication validations on all debug routes
+router.use(logStreamAuth);
+
+/**
+ * GET /api/debug/server-logs
+ * Exposes a real-time SSE stream of intercepted server stdout/stderr logs.
+ */
+router.get('/server-logs', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no'
+  });
+
+  // Send historical server logs buffer first
+  for (const line of logBuffer) {
+    res.write(`data: ${line}\n\n`);
+  }
+
+  // Gracefully close for integration testing
+  if (req.query.testClose === 'true') {
+    res.end();
+    return;
+  }
+
+  const sendLog = (line) => {
+    try {
+      res.write(`data: ${line}\n\n`);
+    } catch (err) {
+      console.error('[debugRoutes] Error sending server log line:', err.message);
+    }
+  };
+
+  logEmitter.on('server-log', sendLog);
+
+  // 25s heartbeat comment to prevent proxy timeouts
+  const heartbeat = setInterval(() => {
+    try {
+      res.write(': heartbeat\n\n');
+    } catch {
+      // Ignore
+    }
+  }, 25000);
+
+  req.on('close', () => {
+    clearInterval(heartbeat);
+    logEmitter.off('server-log', sendLog);
+  });
+});
+
+/**
+ * GET /api/debug/client-logs
+ * Exposes a real-time SSE stream of ingested client-side console logs.
+ */
+router.get('/client-logs', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no'
+  });
+
+  // Send historical client logs buffer first
+  for (const line of clientLogBuffer) {
+    res.write(`data: ${line}\n\n`);
+  }
+
+  // Gracefully close for integration testing
+  if (req.query.testClose === 'true') {
+    res.end();
+    return;
+  }
+
+  const sendClientLog = (line) => {
+    try {
+      res.write(`data: ${line}\n\n`);
+    } catch (err) {
+      console.error('[debugRoutes] Error sending client log line:', err.message);
+    }
+  };
+
+  logEmitter.on('client-log', sendClientLog);
+
+  // 25s heartbeat comment to prevent proxy timeouts
+  const heartbeat = setInterval(() => {
+    try {
+      res.write(': heartbeat\n\n');
+    } catch {
+      // Ignore
+    }
+  }, 25000);
+
+  req.on('close', () => {
+    clearInterval(heartbeat);
+    logEmitter.off('client-log', sendClientLog);
+  });
+});
+
+/**
+ * POST /api/debug/client-logs
+ * Receives batches of frontend console logs to store in buffer and emit.
+ */
+router.post('/client-logs', (req, res) => {
+  const logs = req.body;
+  if (!Array.isArray(logs)) {
+    return res.status(400).json({ error: 'Body must be a JSON array of log entries' });
+  }
+
+  try {
+    ingestClientLogs(logs);
+    return res.status(200).json({ success: true, count: logs.length });
+  } catch (err) {
+    console.error('[debugRoutes] Ingestion failed:', err.message);
+    return res.status(500).json({ error: 'Internal server error during ingestion' });
+  }
+});
+
+module.exports = router;

server/routes/emby.js

@@ -5,9 +5,26 @@ const router = express.Router();
 const requireAuth = require('../middleware/requireAuth');
 const sanitizeError = require('../utils/sanitizeError');
 
+/**
+ * @openapi
+ * /api/emby/sessions:
+ *   get:
+ *     tags: [Emby]
+ *     summary: Get active Emby sessions
+ *     description: Proxy to Emby's sessions endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Sessions data from Emby
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ */
 router.use(requireAuth);
 
-// Get active sessions
+// GET /api/emby/sessions - list active Emby sessions
 router.get('/sessions', async (req, res) => {
   try {
     const response = await axios.get(`${process.env.EMBY_URL}/Sessions`, {
@@ -19,19 +36,24 @@ router.get('/sessions', async (req, res) => {
   }
 });
 
-// Get user by ID
-router.get('/users/:id', async (req, res) => {
-  try {
-    const response = await axios.get(`${process.env.EMBY_URL}/Users/${req.params.id}`, {
-      headers: { 'X-MediaBrowser-Token': process.env.EMBY_API_KEY }
-    });
-    res.json(response.data);
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to fetch user details', details: sanitizeError(error) });
-  }
-});
-
-// Get all users
+/**
+ * @openapi
+ * /api/emby/users:
+ *   get:
+ *     tags: [Emby]
+ *     summary: Get all Emby users
+ *     description: Proxy to Emby's users list endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Users list from Emby
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ */
+// GET /api/emby/users - list all users
 router.get('/users', async (req, res) => {
   try {
     const response = await axios.get(`${process.env.EMBY_URL}/Users`, {
@@ -43,7 +65,79 @@ router.get('/users', async (req, res) => {
   }
 });
 
-// Get current user by session ID
+/**
+ * @openapi
+ * /api/emby/users/{id}:
+ *   get:
+ *     tags: [Emby]
+ *     summary: Get user by ID
+ *     description: Get details for a specific Emby user by ID. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Emby user ID
+ *     responses:
+ *       '200':
+ *         description: User data from Emby
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '500':
+ *         description: Failed to fetch user from Emby
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+// GET /api/emby/users/:id - get individual user by ID
+router.get('/users/:id', async (req, res) => {
+  try {
+    const response = await axios.get(`${process.env.EMBY_URL}/Users/${req.params.id}`, {
+      headers: { 'X-MediaBrowser-Token': process.env.EMBY_API_KEY }
+    });
+    res.json(response.data);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch user', details: sanitizeError(error) });
+  }
+});
+
+/**
+ * @openapi
+ * /api/emby/session/{sessionId}/user:
+ *   get:
+ *     tags: [Emby]
+ *     summary: Get user from session
+ *     description: Get user details for a specific session ID. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: sessionId
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: string
+ *         description: Emby session ID
+ *     responses:
+ *       '200':
+ *         description: User data from Emby
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '404':
+ *         description: Session not found
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+// GET /api/emby/session/:sessionId/user - get user for a specific session
 router.get('/session/:sessionId/user', async (req, res) => {
   try {
     const response = await axios.get(`${process.env.EMBY_URL}/Sessions`, {

server/routes/history.js

@@ -1,119 +1,14 @@
 // Copyright (c) 2026 Gordon Bolton. MIT License.
 const express = require('express');
 const router = express.Router();
-const axios = require('axios');
 const requireAuth = require('../middleware/requireAuth');
 const cache = require('../utils/cache');
 const { fetchSonarrHistory, fetchRadarrHistory, classifySonarrEvent, classifyRadarrEvent } = require('../utils/historyFetcher');
-const { getSonarrInstances, getRadarrInstances } = require('../utils/config');
+const { getSonarrInstances, getRadarrInstances, getOmbiInstances } = require('../utils/config');
 const sanitizeError = require('../utils/sanitizeError');
+const TagMatcher = require('../services/TagMatcher');
+const DownloadAssembler = require('../services/DownloadAssembler');
 
-// Re-use the same tag/cover-art helpers as dashboard.js by importing them
-// from a shared location.  For now they are inlined here to keep dashboard.js
-// untouched (zero-conflict v1 merges).  If these diverge they can be extracted
-// into server/utils/dashboardHelpers.js in a later refactor.
-
-function getCoverArt(item) {
-  if (!item || !item.images) return null;
-  const poster = item.images.find(img => img.coverType === 'poster');
-  if (poster) return poster.remoteUrl || poster.url || null;
-  const fanart = item.images.find(img => img.coverType === 'fanart');
-  return fanart ? (fanart.remoteUrl || fanart.url || null) : null;
-}
-
-function sanitizeTagLabel(input) {
-  if (!input) return '';
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-}
-
-function tagMatchesUser(tag, username) {
-  if (!tag || !username) return false;
-  const tagLower = tag.toLowerCase();
-  if (tagLower === username) return true;
-  if (tagLower === sanitizeTagLabel(username)) return true;
-  return false;
-}
-
-function extractAllTags(tags, tagMap) {
-  if (!tags || tags.length === 0) return [];
-  if (tagMap) return tags.map(id => tagMap.get(id)).filter(Boolean);
-  return tags.map(t => t && t.label).filter(Boolean);
-}
-
-function extractUserTag(tags, tagMap, username) {
-  const allLabels = extractAllTags(tags, tagMap);
-  if (!allLabels.length) return null;
-  if (username) {
-    const match = allLabels.find(label => tagMatchesUser(label, username));
-    if (match) return match;
-  }
-  return null;
-}
-
-async function getEmbyUsers() {
-  const cached = cache.get('emby:users');
-  if (cached) return cached;
-  try {
-    const embyUrl = process.env.EMBY_URL;
-    const embyKey = process.env.EMBY_API_KEY;
-    if (!embyUrl || !embyKey) return new Map();
-    const res = await axios.get(`${embyUrl}/Users`, { params: { api_key: embyKey } });
-    const users = res.data || [];
-    const map = new Map();
-    for (const u of users) {
-      if (!u.Name) continue;
-      const lower = u.Name.toLowerCase();
-      map.set(lower, u.Name);
-      map.set(sanitizeTagLabel(lower), u.Name);
-    }
-    cache.set('emby:users', map, 60000);
-    return map;
-  } catch (err) {
-    console.error('[History] Failed to fetch Emby users:', err.message);
-    return new Map();
-  }
-}
-
-function buildTagBadges(allTags, embyUserMap) {
-  return allTags.map(label => {
-    const lower = label.toLowerCase();
-    const sanitized = sanitizeTagLabel(label);
-    const matchedUser = embyUserMap.get(lower) || embyUserMap.get(sanitized) || null;
-    return { label, matchedUser };
-  });
-}
-
-// Extract episode info from a Sonarr history record.
-function extractEpisode(record) {
-  const ep = record.episode || {};
-  const s = ep.seasonNumber != null ? ep.seasonNumber : record.seasonNumber;
-  const e = ep.episodeNumber != null ? ep.episodeNumber : record.episodeNumber;
-  if (s == null || e == null) return null;
-  const title = ep.title || null;
-  return { season: s, episode: e, title };
-}
-
-// Find all episodes associated with a download by matching all history records
-// that share the same source title.  Returns sorted, deduplicated array.
-function gatherEpisodes(titleLower, records) {
-  const episodes = [];
-  const seen = new Set();
-  for (const r of records) {
-    const rTitle = (r.sourceTitle || r.title || '').toLowerCase();
-    if (rTitle && (rTitle.includes(titleLower) || titleLower.includes(rTitle))) {
-      const ep = extractEpisode(r);
-      if (ep) {
-        const key = `${ep.season}x${ep.episode}`;
-        if (!seen.has(key)) {
-          seen.add(key);
-          episodes.push(ep);
-        }
-      }
-    }
-  }
-  episodes.sort((a, b) => a.season - b.season || a.episode - b.episode);
-  return episodes;
-}
 
 /**
  * Deduplicate history items so that for each unique content item (episode or
@@ -184,49 +79,139 @@ function deduplicateHistoryItems(items, sonarrRaw, radarrRaw) {
   return result;
 }
 
-function getSonarrLink(series) {
-  if (!series || !series._instanceUrl || !series.titleSlug) return null;
-  return `${series._instanceUrl}/series/${series.titleSlug}`;
-}
 
-function getRadarrLink(movie) {
-  if (!movie || !movie._instanceUrl || !movie.titleSlug) return null;
-  return `${movie._instanceUrl}/movie/${movie.titleSlug}`;
-}
 
 /**
- * GET /api/history/recent
+ * @openapi
+ * /api/history/recent:
+ *   get:
+ *     tags: [History]
+ *     summary: Get recent history
+ *     description: |
+ *       Returns Sonarr/Radarr history records (imported + failed) for the authenticated user,
+ *       filtered to the last N days (default 7, max 90).
  *
- * Returns Sonarr/Radarr history records (imported + failed) for the
- * authenticated user, filtered to the last RECENT_COMPLETED_DAYS days
- * (default 7, overridable via env or ?days= query param).
+ *       **Authentication:** Requires valid `emby_user` cookie.
  *
- * Response shape:
- * {
- *   user: string,
- *   isAdmin: boolean,
- *   days: number,
- *   history: HistoryItem[]
- * }
+ *       **Filtering:**
+ *       - Non-admin users: Only see history items tagged with their username
+ *       - Admin users: Can see all history by setting query parameter `showAll=true`
+ *       - Date range: Configurable via `?days=` query parameter (default: 7, max: 90)
  *
- * HistoryItem shape:
- * {
- *   type: 'series'|'movie',
- *   outcome: 'imported'|'failed',
- *   title: string,            // sourceTitle from arr record
- *   seriesName?: string,      // series.title (Sonarr)
- *   movieName?: string,       // movie.title (Radarr)
- *   coverArt: string|null,
- *   completedAt: string,      // ISO date string from arr record
- *   quality: string|null,
- *   instanceName: string,     // arr instance name
- *   arrLink: string|null,     // link to item in Sonarr/Radarr UI
- *   allTags: string[],
- *   matchedUserTag: string|null,
- *   // admin-only:
- *   arrRecordId?: number,
- *   failureMessage?: string,
- * }
+ *       **Deduplication Rules:**
+ *       For each unique content item (episode or movie), only the most recent record is shown:
+ *       - If the most recent event is "imported" → show it; suppress older failures
+ *       - If the most recent event is "failed" and the item has a file on disk → show with `availableForUpgrade=true`
+ *       - If the most recent event is "failed" and no file exists → show normally
+ *
+ *       **Event Classification:**
+ *       - Sonarr: DownloadFolderImported, ImportFailed → included
+ *       - Radarr: DownloadFolderImported, ImportFailed → included
+ *       - Other event types (Rename, Health, etc.) → excluded
+ *
+ *       **Response Structure:**
+ *       - `type`: "series" or "movie"
+ *       - `outcome`: "imported" or "failed"
+ *       - `title`: Source title from *arr record
+ *       - `seriesName`/`movieName`: Friendly media title
+ *       - `coverArt`: Poster URL
+ *       - `completedAt`: ISO 8601 timestamp
+ *       - `quality`: Quality string (e.g., "HDTV-1080p")
+ *       - `instanceName`: *arr instance name
+ *       - `arrLink`: Link to item in *arr UI
+ *       - `allTags`: All tags on the series/movie
+ *       - `matchedUserTag`: Tag matching the requesting user
+ *       - `availableForUpgrade`: True if failed but content is on disk (admin-only)
+ *       - `failureMessage`: Failure details (admin-only)
+ *
+ *       **x-integration-notes:** Used by the history tab to show recently completed downloads.
+ *       Episodes are gathered from all history records sharing the same source title.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: days
+ *         in: query
+ *         schema:
+ *           type: integer
+ *           minimum: 1
+ *           maximum: 90
+ *           default: 7
+ *         description: Number of days to look back (max 90)
+ *         example: 7
+ *       - name: showAll
+ *         in: query
+ *         schema:
+ *           type: boolean
+ *           default: false
+ *         description: 'Admin-only: show all users'' history'
+ *     responses:
+ *       '200':
+ *         description: History items
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 user:
+ *                   type: string
+ *                   example: "john"
+ *                 isAdmin:
+ *                   type: boolean
+ *                   example: false
+ *                 days:
+ *                   type: integer
+ *                   example: 7
+ *                 history:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/HistoryItem'
+ *             example:
+ *               user: "john"
+ *               isAdmin: false
+ *               days: 7
+ *               history:
+ *                 - type: "series"
+ *                   outcome: "imported"
+ *                   title: "Show.Name.S01E01.1080p.WEB-DL"
+ *                   seriesName: "Show Name"
+ *                   episodes:
+ *                     - season: 1
+ *                       episode: 1
+ *                       title: "Pilot"
+ *                   coverArt: "http://sonarr:8989/media/poster.jpg"
+ *                   completedAt: "2026-05-21T10:00:00.000Z"
+ *                   quality: "HDTV-1080p"
+ *                   instanceName: "Main Sonarr"
+ *                   arrLink: "http://sonarr:8989/series/show-slug"
+ *                   allTags: ["user-john"]
+ *                   matchedUserTag: "user-john"
+ *       '401':
+ *         description: Not authenticated
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '500':
+ *         description: Server error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           curl -X GET "http://localhost:3001/api/history/recent?days=7" \
+ *             -b cookies.txt
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const response = await fetch('http://localhost:3001/api/history/recent?days=7', {
+ *             method: 'GET',
+ *             credentials: 'include'
+ *           });
+ *           const data = await response.json();
+ *           console.log('History items:', data.history.length);
  */
 router.get('/recent', requireAuth, async (req, res) => {
   try {
@@ -245,10 +230,13 @@ router.get('/recent', requireAuth, async (req, res) => {
     const sonarrInstances = getSonarrInstances();
     const radarrInstances = getRadarrInstances();
 
+    const ombiInstances = getOmbiInstances();
+    const ombiBaseUrl = ombiInstances.length > 0 ? ombiInstances[0].url : null;
+
     const [sonarrHistory, radarrHistory, embyUserMap] = await Promise.all([
       fetchSonarrHistory(since),
       fetchRadarrHistory(since),
-      showAll ? getEmbyUsers() : Promise.resolve(new Map())
+      showAll ? TagMatcher.getEmbyUsers() : Promise.resolve(new Map())
     ]);
 
     // Build tag maps from the cached poll data where available,
@@ -269,8 +257,8 @@ router.get('/recent', requireAuth, async (req, res) => {
         const series = record.series;
         if (!series) continue;
 
-        const allTags = extractAllTags(series.tags, sonarrTagMap);
-        const matchedUserTag = extractUserTag(series.tags, sonarrTagMap, username);
+        const allTags = TagMatcher.extractAllTags(series.tags, sonarrTagMap);
+        const matchedUserTag = TagMatcher.extractUserTag(series.tags, sonarrTagMap, username);
         const hasAnyTag = allTags.length > 0;
 
         if (!(showAll ? hasAnyTag : !!matchedUserTag)) continue;
@@ -285,20 +273,23 @@ router.get('/recent', requireAuth, async (req, res) => {
           outcome,
           title: sourceTitle,
           seriesName: series.title,
-          episodes: gatherEpisodes(sourceTitle.toLowerCase(), sonarrHistory),
-          coverArt: getCoverArt(series),
+          episodes: DownloadAssembler.gatherEpisodes(sourceTitle.toLowerCase(), sonarrHistory),
+          coverArt: DownloadAssembler.getCoverArt(series),
           completedAt: record.date,
           quality,
           instanceName: record._instanceName || null,
-          arrLink: getSonarrLink(series),
+          arrLink: DownloadAssembler.getSonarrLink(series),
+          ombiLink: DownloadAssembler.getOmbiDetailsLink(series, 'series', ombiBaseUrl),
+          ombiTooltip: 'View in Ombi',
           allTags,
           matchedUserTag: matchedUserTag || null,
-          tagBadges: showAll ? buildTagBadges(allTags, embyUserMap) : undefined,
+          tagBadges: showAll ? TagMatcher.buildTagBadges(allTags, embyUserMap) : undefined,
           _contentId: record.episodeId != null ? record.episodeId : null
         };
 
         if (isAdmin) {
           item.arrRecordId = record.id;
+          item.arrType = 'sonarr';
           if (outcome === 'failed' && record.data && record.data.message) {
             item.failureMessage = record.data.message;
           }
@@ -319,8 +310,8 @@ router.get('/recent', requireAuth, async (req, res) => {
         const movie = record.movie;
         if (!movie) continue;
 
-        const allTags = extractAllTags(movie.tags, radarrTagMap);
-        const matchedUserTag = extractUserTag(movie.tags, radarrTagMap, username);
+        const allTags = TagMatcher.extractAllTags(movie.tags, radarrTagMap);
+        const matchedUserTag = TagMatcher.extractUserTag(movie.tags, radarrTagMap, username);
         const hasAnyTag = allTags.length > 0;
 
         if (!(showAll ? hasAnyTag : !!matchedUserTag)) continue;
@@ -334,19 +325,22 @@ router.get('/recent', requireAuth, async (req, res) => {
           outcome,
           title: record.sourceTitle || record.title || movie.title,
           movieName: movie.title,
-          coverArt: getCoverArt(movie),
+          coverArt: DownloadAssembler.getCoverArt(movie),
           completedAt: record.date,
           quality,
           instanceName: record._instanceName || null,
-          arrLink: getRadarrLink(movie),
+          arrLink: DownloadAssembler.getRadarrLink(movie),
+          ombiLink: DownloadAssembler.getOmbiDetailsLink(movie, 'movie', ombiBaseUrl),
+          ombiTooltip: 'View in Ombi',
           allTags,
           matchedUserTag: matchedUserTag || null,
-          tagBadges: showAll ? buildTagBadges(allTags, embyUserMap) : undefined,
+          tagBadges: showAll ? TagMatcher.buildTagBadges(allTags, embyUserMap) : undefined,
           _contentId: record.movieId != null ? record.movieId : null
         };
 
         if (isAdmin) {
           item.arrRecordId = record.id;
+          item.arrType = 'radarr';
           if (outcome === 'failed' && record.data && record.data.message) {
             item.failureMessage = record.data.message;
           }

server/routes/ombi.js

@@ -0,0 +1,559 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const express = require('express');
+const { logToFile } = require('../utils/logger');
+const cache = require('../utils/cache');
+const { getOmbiInstances, getWebhookSecret, getSofarrBaseUrl, getSofarrWebhookBaseUrl } = require('../utils/config');
+const requireAuth = require('../middleware/requireAuth');
+const { extractRequestedUser, filterRequestsByUser, decorateRequestsWithArrLinks } = require('../utils/ombiHelpers');
+const { applyRequestFilters } = require('../utils/ombiFilters');
+
+const router = express.Router();
+
+/**
+ * @openapi
+ * /api/ombi/requests:
+ *   get:
+ *     tags: [Ombi]
+ *     summary: Get Ombi requests
+ *     description: |
+ *       Returns Ombi movie and TV requests. Non-admin users only see their own requests
+ *       (filtered by Emby user mapping), while admins see all requests.
+ *
+ *       Supports server-side filtering by media type, request status, title search,
+ *       and sorting by requested date or title.
+ *
+ *       **Authentication:** Requires cookie authentication.
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - name: type
+ *         in: query
+ *         schema:
+ *           type: array
+ *           items:
+ *             type: string
+ *             enum: [movie, tv, all]
+ *           default: [all]
+ *         description: Filter by media type. Omit or use `all` for both.
+ *         style: form
+ *         explode: true
+ *       - name: status
+ *         in: query
+ *         schema:
+ *           type: array
+ *           items:
+ *             type: string
+ *             enum: [pending, approved, available, denied]
+ *         description: Filter by request status. Omit for all statuses.
+ *         style: form
+ *         explode: true
+ *       - name: sort
+ *         in: query
+ *         schema:
+ *           type: string
+ *           enum: [requestedDate_desc, requestedDate_asc, title_asc, title_desc]
+ *           default: requestedDate_desc
+ *         description: Sort mode.
+ *       - name: search
+ *         in: query
+ *         schema:
+ *           type: string
+ *         description: Case-insensitive substring match on title.
+ *       - name: showAll
+ *         in: query
+ *         schema:
+ *           type: string
+ *           enum: ['true', 'false']
+ *         description: Admin only. Show all users' requests.
+ *     responses:
+ *       '200':
+ *         description: Ombi requests retrieved successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 user:
+ *                   type: string
+ *                   example: "username"
+ *                 isAdmin:
+ *                   type: boolean
+ *                   example: false
+ *                 showAll:
+ *                   type: boolean
+ *                   example: false
+ *                 requests:
+ *                   type: object
+ *                   properties:
+ *                     movie:
+ *                       type: array
+ *                       items:
+ *                         $ref: '#/components/schemas/OmbiRequest'
+ *                     tv:
+ *                       type: array
+ *                       items:
+ *                         $ref: '#/components/schemas/OmbiRequest'
+ *                 total:
+ *                   type: integer
+ *                   example: 5
+ *       '401':
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+router.get('/requests', requireAuth, async (req, res) => {
+  try {
+    const user = req.user;
+    const isAdmin = user.isAdmin;
+    const username = user.name;
+    const showAll = isAdmin && req.query.showAll === 'true';
+
+    const arrRetrieverRegistry = require('../utils/arrRetrievers');
+    // initialize() is idempotent - cheap no-op if already initialized
+    await arrRetrieverRegistry.initialize();
+
+    const ombiRequests = await arrRetrieverRegistry.getOmbiRequests(true);
+
+    // Filter by user if not admin or if showAll is false
+    const filteredMovieRequests = filterRequestsByUser(ombiRequests.movie || [], username, showAll);
+    const filteredTvRequests = filterRequestsByUser(ombiRequests.tv || [], username, showAll);
+
+    // Tag with mediaType and flatten for filtering/sorting
+    const allRequests = [
+      ...filteredMovieRequests.map(r => ({ ...r, mediaType: 'movie' })),
+      ...filteredTvRequests.map(r => ({ ...r, mediaType: 'tv' }))
+    ];
+
+    // Admin only: add Sonarr/Radarr lookup links
+    if (isAdmin) {
+      await decorateRequestsWithArrLinks(allRequests, isAdmin);
+    }
+
+    // Parse query params
+    let types = req.query.type;
+    let statuses = req.query.status;
+    const sort = req.query.sort || 'requestedDate_desc';
+    const search = req.query.search || '';
+
+    // Normalise to arrays
+    if (typeof types === 'string') types = [types];
+    if (typeof statuses === 'string') statuses = [statuses];
+
+    // Apply filters and sorting
+    const filtered = applyRequestFilters(allRequests, { types, statuses, sort, search });
+
+    // Split back into movie/tv
+    const movie = filtered.filter(r => r.mediaType === 'movie');
+    const tv = filtered.filter(r => r.mediaType === 'tv');
+
+    const total = filtered.length;
+
+    res.json({
+      user: username,
+      isAdmin,
+      showAll,
+      requests: { movie, tv },
+      total
+    });
+  } catch (error) {
+    logToFile(`[Ombi] Error fetching requests: ${error.message}`);
+    res.status(500).json({ error: 'Failed to fetch Ombi requests' });
+  }
+});
+
+/**
+ * @openapi
+ * /api/ombi/webhook/enable:
+ *   post:
+ *     tags: [Ombi]
+ *     summary: Enable Ombi webhook
+ *     description: |
+ *       Registers or updates the Sofarr webhook in Ombi. Requires authentication and CSRF protection.
+ *
+ *       **Authentication:** Requires cookie authentication.
+ *       **CSRF:** Requires X-CSRF-Token header matching csrf_token cookie.
+ *     security:
+ *       - cookieAuth: []
+ *     requestBody:
+ *       required: false
+ *     responses:
+ *       '200':
+ *         description: Webhook enabled successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 webhookUrl:
+ *                   type: string
+ *                   example: "https://sofarr.example.com/api/webhook/ombi"
+ *                 applicationToken:
+ *                   type: string
+ *                   example: "your-ombi-api-key"
+ *       '400':
+ *         description: Invalid request or missing configuration
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '401':
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+router.post('/webhook/enable', requireAuth, async (req, res) => {
+  try {
+    const webhookBaseUrl = getSofarrWebhookBaseUrl();
+    const webhookSecret = getWebhookSecret();
+
+    if (!webhookBaseUrl) {
+      return res.status(400).json({ error: 'SOFARR_BASE_URL not configured' });
+    }
+    if (!webhookSecret) {
+      return res.status(400).json({ error: 'SOFARR_WEBHOOK_SECRET not configured' });
+    }
+
+    const ombiInstances = getOmbiInstances();
+    if (ombiInstances.length === 0) {
+      return res.status(400).json({ error: 'Ombi not configured' });
+    }
+
+    const ombiInst = ombiInstances[0];
+    const webhookUrl = `${webhookBaseUrl}/api/webhook/ombi?secret=${webhookSecret}`;
+
+    // Call Ombi API to register webhook
+    const axios = require('axios');
+
+    // Get existing settings to retrieve the database ID
+    const currentRes = await axios.get(
+      `${ombiInst.url}/api/v1/Settings/notifications/webhook`,
+      {
+        headers: {
+          'ApiKey': ombiInst.apiKey
+        }
+      }
+    ).catch(err => {
+      logToFile(`[Ombi] Warning fetching existing webhook settings: ${err.message}`);
+      return { data: {} };
+    });
+
+    const currentConfig = currentRes.data || {};
+    const settingsId = currentConfig.id || 0;
+
+    const response = await axios.post(
+      `${ombiInst.url}/api/v1/Settings/notifications/webhook`,
+      {
+        id: settingsId,
+        enabled: true,
+        webhookUrl: webhookUrl,
+        applicationToken: ombiInst.apiKey
+      },
+      {
+        headers: {
+          'ApiKey': ombiInst.apiKey,
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    logToFile(`[Ombi] Webhook enabled: ${webhookUrl}`);
+
+    res.json({
+      success: true,
+      webhookUrl: webhookUrl,
+      applicationToken: ombiInst.apiKey
+    });
+  } catch (error) {
+    logToFile(`[Ombi] Error enabling webhook: ${error.message}`);
+    res.status(500).json({ error: 'Failed to enable Ombi webhook' });
+  }
+});
+
+/**
+ * @openapi
+ * /api/ombi/webhook/status:
+ *   get:
+ *     tags: [Ombi]
+ *     summary: Get Ombi webhook status
+ *     description: |
+ *       Returns the current Ombi webhook configuration status and metrics.
+ *
+ *       **Authentication:** Requires cookie authentication.
+ *     security:
+ *       - cookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Webhook status retrieved successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 enabled:
+ *                   type: boolean
+ *                   example: true
+ *                 webhookUrl:
+ *                   type: string
+ *                   nullable: true
+ *                   example: "https://sofarr.example.com/api/webhook/ombi"
+ *                 applicationToken:
+ *                   type: string
+ *                   nullable: true
+ *                   example: "your-ombi-api-key"
+ *                 triggers:
+ *                   type: object
+ *                   properties:
+ *                     requestAvailable:
+ *                       type: boolean
+ *                       example: true
+ *                     requestApproved:
+ *                       type: boolean
+ *                       example: true
+ *                     requestDeclined:
+ *                       type: boolean
+ *                       example: true
+ *                     requestPending:
+ *                       type: boolean
+ *                       example: true
+ *                     requestProcessing:
+ *                       type: boolean
+ *                       example: true
+ *                 stats:
+ *                   type: object
+ *                   properties:
+ *                     eventsReceived:
+ *                       type: integer
+ *                       example: 10
+ *                     pollsSkipped:
+ *                       type: integer
+ *                       example: 5
+ *                     lastWebhookTimestamp:
+ *                       type: integer
+ *                       example: 1716326400000
+ *       '401':
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+router.get('/webhook/status', requireAuth, async (req, res) => {
+  try {
+    const sofarrBaseUrl = getSofarrBaseUrl();
+    const webhookSecret = getWebhookSecret();
+
+    // Webhooks require SOFARR_BASE_URL and SOFARR_WEBHOOK_SECRET to be configured
+    if (!sofarrBaseUrl || !webhookSecret) {
+      return res.json({
+        enabled: false,
+        webhookUrl: null,
+        applicationToken: null,
+        triggers: {
+          requestAvailable: false,
+          requestApproved: false,
+          requestDeclined: false,
+          requestPending: false,
+          requestProcessing: false
+        },
+        stats: null
+      });
+    }
+
+    const ombiInstances = getOmbiInstances();
+    if (ombiInstances.length === 0) {
+      return res.json({
+        enabled: false,
+        webhookUrl: null,
+        applicationToken: null,
+        triggers: {
+          requestAvailable: false,
+          requestApproved: false,
+          requestDeclined: false,
+          requestPending: false,
+          requestProcessing: false
+        },
+        stats: null
+      });
+    }
+
+    const ombiInst = ombiInstances[0];
+
+    // Call Ombi API to get webhook status
+    const axios = require('axios');
+    const response = await axios.get(
+      `${ombiInst.url}/api/v1/Settings/notifications/webhook`,
+      {
+        headers: {
+          'ApiKey': ombiInst.apiKey
+        }
+      }
+    );
+
+    const webhookConfig = response.data;
+
+    // Get webhook metrics from cache
+    const metrics = cache.getWebhookMetrics(ombiInst.url);
+
+    res.json({
+      enabled: webhookConfig.enabled || false,
+      webhookUrl: webhookConfig.webhookUrl || null,
+      applicationToken: webhookConfig.applicationToken || null,
+      // Note: Ombi may support per-trigger toggles, but we currently treat
+      // them as all-on or all-off based on webhookConfig.enabled
+      triggers: {
+        requestAvailable: webhookConfig.enabled || false,
+        requestApproved: webhookConfig.enabled || false,
+        requestDeclined: webhookConfig.enabled || false,
+        requestPending: webhookConfig.enabled || false,
+        requestProcessing: webhookConfig.enabled || false
+      },
+      stats: metrics ? {
+        eventsReceived: metrics.eventsReceived || 0,
+        pollsSkipped: metrics.pollsSkipped || 0,
+        lastWebhookTimestamp: metrics.lastWebhookTimestamp || null
+      } : null
+    });
+  } catch (error) {
+    logToFile(`[Ombi] Error fetching webhook status: ${error.message}`);
+    res.status(500).json({ error: 'Failed to fetch Ombi webhook status' });
+  }
+});
+
+/**
+ * @openapi
+ * /api/ombi/webhook/test:
+ *   post:
+ *     tags: [Ombi]
+ *     summary: Test Ombi webhook
+ *     description: |
+ *       Sends a test webhook event to the Sofarr Ombi webhook endpoint.
+ *
+ *       **Authentication:** Requires cookie authentication and CSRF token.
+ *     security:
+ *       - cookieAuth: []
+ *       - CsrfToken: []
+ *     requestBody:
+ *       required: false
+ *     responses:
+ *       '200':
+ *         description: Test webhook sent successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *       '400':
+ *         description: Invalid request or missing configuration
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '401':
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+router.post('/webhook/test', requireAuth, async (req, res) => {
+  try {
+    const webhookBaseUrl = getSofarrWebhookBaseUrl();
+    const webhookSecret = getWebhookSecret();
+
+    if (!webhookBaseUrl) {
+      return res.status(400).json({ error: 'SOFARR_BASE_URL not configured' });
+    }
+    if (!webhookSecret) {
+      return res.status(400).json({ error: 'SOFARR_WEBHOOK_SECRET not configured' });
+    }
+
+    const ombiInstances = getOmbiInstances();
+    if (ombiInstances.length === 0) {
+      return res.status(400).json({ error: 'Ombi not configured' });
+    }
+
+    const ombiInst = ombiInstances[0];
+    const webhookUrl = `${webhookBaseUrl}/api/webhook/ombi`;
+
+    // Simulate a test webhook event
+    const axios = require('axios');
+    try {
+      await axios.post(webhookUrl, {
+        notificationType: 'RequestAvailable',
+        requestId: 0,
+        requestedUser: 'test',
+        title: 'Test Request',
+        type: 'Movie',
+        requestStatus: 'Pending'
+      }, {
+        headers: {
+          'X-Sofarr-Webhook-Secret': webhookSecret,
+          'Content-Type': 'application/json'
+        }
+      });
+      logToFile(`[Ombi] Test webhook sent to ${webhookUrl}`);
+    } catch (error) {
+      logToFile(`[Ombi] Public test webhook request to ${webhookUrl} failed: ${error.message}. Trying local loopback fallback.`);
+      
+      const port = process.env.PORT || 3001;
+      const tlsEnabled = (process.env.TLS_ENABLED || 'true').toLowerCase() !== 'false';
+      
+      let useHttps = false;
+      if (tlsEnabled) {
+        const fs = require('fs');
+        const path = require('path');
+        const certsDir = path.join(__dirname, '../../certs');
+        const tlsCertPath = process.env.TLS_CERT || path.join(certsDir, 'snakeoil.crt');
+        const tlsKeyPath  = process.env.TLS_KEY  || path.join(certsDir, 'snakeoil.key');
+        try {
+          fs.readFileSync(tlsCertPath);
+          fs.readFileSync(tlsKeyPath);
+          useHttps = true;
+        } catch {
+          useHttps = false;
+        }
+      }
+      
+      const localUrl = `${useHttps ? 'https' : 'http'}://127.0.0.1:${port}/api/webhook/ombi`;
+      
+      const https = require('https');
+      const agent = new https.Agent({
+        rejectUnauthorized: false
+      });
+      
+      await axios.post(localUrl, {
+        notificationType: 'RequestAvailable',
+        requestId: 0,
+        requestedUser: 'test',
+        title: 'Test Request',
+        type: 'Movie',
+        requestStatus: 'Pending'
+      }, {
+        headers: {
+          'X-Sofarr-Webhook-Secret': webhookSecret,
+          'Content-Type': 'application/json'
+        },
+        httpsAgent: useHttps ? agent : undefined
+      });
+      
+      logToFile(`[Ombi] Test webhook sent via local loopback to ${localUrl}`);
+    }
+
+    res.json({ success: true });
+  } catch (error) {
+    logToFile(`[Ombi] Error testing webhook: ${error.message}`);
+    res.status(500).json({ error: 'Failed to test Ombi webhook' });
+  }
+});
+
+module.exports = router;

server/routes/radarr.js

@@ -4,7 +4,7 @@ const axios = require('axios');
 const router = express.Router();
 const requireAuth = require('../middleware/requireAuth');
 const sanitizeError = require('../utils/sanitizeError');
-const { getWebhookSecret, getSofarrBaseUrl, getRadarrInstances } = require('../utils/config');
+const { getWebhookSecret, getSofarrBaseUrl, getRadarrInstances, getSofarrWebhookBaseUrl } = require('../utils/config');
 
 // Helper to get first Radarr instance (for notification proxy routes)
 function getFirstRadarrInstance() {
@@ -15,13 +15,41 @@ function getFirstRadarrInstance() {
   return instances[0];
 }
 
+/**
+ * @openapi
+ * /api/radarr/queue:
+ *   get:
+ *     tags: [Radarr]
+ *     summary: Get Radarr queue
+ *     description: Proxy to Radarr's queue endpoint. Requires authentication and CSRF token.
+ *     security:
+ *       - CookieAuth: []
+ *       - CsrfToken: []
+ *     responses:
+ *       '200':
+ *         description: Queue data from Radarr
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '500':
+ *         description: Proxy error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
 router.use(requireAuth);
 
 // Get queue
 router.get('/queue', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/queue`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/queue`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -29,11 +57,39 @@ router.get('/queue', async (req, res) => {
   }
 });
 
+/**
+ * @openapi
+ * /api/radarr/history:
+ *   get:
+ *     tags: [Radarr]
+ *     summary: Get Radarr history
+ *     description: Proxy to Radarr's history endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: pageSize
+ *         in: query
+ *         schema:
+ *           type: integer
+ *           default: 50
+ *         description: Number of records per page
+ *     responses:
+ *       '200':
+ *         description: History data from Radarr
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ */
 // Get history
 router.get('/history', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/history`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY },
+    const response = await axios.get(`${instance.url}/api/v3/history`, {
+      headers: { 'X-Api-Key': instance.apiKey },
       params: { pageSize: req.query.pageSize || 50 }
     });
     res.json(response.data);
@@ -44,9 +100,13 @@ router.get('/history', async (req, res) => {
 
 // Get movie details
 router.get('/movies/:id', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/movie/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/movie/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -56,9 +116,13 @@ router.get('/movies/:id', async (req, res) => {
 
 // Get all movies with tags
 router.get('/movies', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/movie`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/movie`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -66,6 +130,36 @@ router.get('/movies', async (req, res) => {
   }
 });
 
+/**
+ * @openapi
+ * /api/radarr/notifications/sofarr-webhook:
+ *   post:
+ *     tags: [Radarr]
+ *     summary: Configure Sofarr webhook
+ *     description: One-click setup for Sofarr webhook notification in Radarr. Requires authentication and CSRF token.
+ *     security:
+ *       - CookieAuth: []
+ *       - CsrfToken: []
+ *     responses:
+ *       '200':
+ *         description: Configured notification
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '400':
+ *         description: Missing configuration
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '503':
+ *         description: Radarr not configured
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
 // Notification proxy routes (Phase 3)
 // GET /api/radarr/notifications - list all notifications
 router.get('/notifications', async (req, res) => {
@@ -86,9 +180,13 @@ router.get('/notifications', async (req, res) => {
 
 // GET /api/radarr/notifications/:id - get specific notification
 router.get('/notifications/:id', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/notification/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -98,9 +196,13 @@ router.get('/notifications/:id', async (req, res) => {
 
 // POST /api/radarr/notifications - create notification
 router.post('/notifications', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.post(`${process.env.RADARR_URL}/api/v3/notification`, req.body, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.post(`${instance.url}/api/v3/notification`, req.body, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -110,9 +212,13 @@ router.post('/notifications', async (req, res) => {
 
 // PUT /api/radarr/notifications/:id - update notification
 router.put('/notifications/:id', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.put(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, req.body, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.put(`${instance.url}/api/v3/notification/${req.params.id}`, req.body, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -122,9 +228,13 @@ router.put('/notifications/:id', async (req, res) => {
 
 // DELETE /api/radarr/notifications/:id - delete notification
 router.delete('/notifications/:id', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.delete(`${process.env.RADARR_URL}/api/v3/notification/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.delete(`${instance.url}/api/v3/notification/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -155,9 +265,13 @@ router.post('/notifications/test', async (req, res) => {
 
 // GET /api/radarr/notifications/schema - get notification schema
 router.get('/notifications/schema', async (req, res) => {
+  const instance = getFirstRadarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Radarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.RADARR_URL}/api/v3/notification/schema`, {
-      headers: { 'X-Api-Key': process.env.RADARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/notification/schema`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -172,17 +286,17 @@ router.post('/notifications/sofarr-webhook', async (req, res) => {
     return res.status(503).json({ error: 'Radarr not configured' });
   }
   try {
-    const sofarrBaseUrl = getSofarrBaseUrl();
+    const webhookBaseUrl = getSofarrWebhookBaseUrl();
     const webhookSecret = getWebhookSecret();
-
-    if (!sofarrBaseUrl) {
+ 
+    if (!webhookBaseUrl) {
       return res.status(400).json({ error: 'SOFARR_BASE_URL not configured' });
     }
     if (!webhookSecret) {
       return res.status(400).json({ error: 'SOFARR_WEBHOOK_SECRET not configured' });
     }
-
-    const webhookUrl = `${sofarrBaseUrl}/api/webhook/radarr`;
+ 
+    const webhookUrl = `${webhookBaseUrl}/api/webhook/radarr`;
 
     // Check if Sofarr webhook already exists
     const listResponse = await axios.get(`${instance.url}/api/v3/notification`, {

server/routes/sabnzbd.js

@@ -4,16 +4,53 @@ const axios = require('axios');
 const router = express.Router();
 const requireAuth = require('../middleware/requireAuth');
 const sanitizeError = require('../utils/sanitizeError');
+const { getSABnzbdInstances } = require('../utils/config');
 
+// Helper to get first SABnzbd instance
+function getFirstSABnzbdInstance() {
+  const instances = getSABnzbdInstances();
+  if (!instances || instances.length === 0) {
+    return null;
+  }
+  return instances[0];
+}
+
+/**
+ * @openapi
+ * /api/sabnzbd/queue:
+ *   get:
+ *     tags: [SABnzbd]
+ *     summary: Get SABnzbd queue
+ *     description: Proxy to SABnzbd's queue endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Queue data from SABnzbd
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '500':
+ *         description: Proxy error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
 router.use(requireAuth);
 
-// Get current queue
+// GET /api/sabnzbd/queue
 router.get('/queue', async (req, res) => {
+  const instance = getFirstSABnzbdInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'SABnzbd not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SABNZBD_URL}/api`, {
+    const response = await axios.get(`${instance.url}/api`, {
       params: {
         mode: 'queue',
-        apikey: process.env.SABNZBD_API_KEY,
+        apikey: instance.apiKey,
         output: 'json'
       }
     });
@@ -23,13 +60,41 @@ router.get('/queue', async (req, res) => {
   }
 });
 
-// Get history
+/**
+ * @openapi
+ * /api/sabnzbd/history:
+ *   get:
+ *     tags: [SABnzbd]
+ *     summary: Get SABnzbd history
+ *     description: Proxy to SABnzbd's history endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: limit
+ *         in: query
+ *         schema:
+ *           type: integer
+ *           default: 50
+ *         description: Number of history records to return
+ *     responses:
+ *       '200':
+ *         description: History data from SABnzbd
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ */
+// GET /api/sabnzbd/history
 router.get('/history', async (req, res) => {
+  const instance = getFirstSABnzbdInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'SABnzbd not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SABNZBD_URL}/api`, {
+    const response = await axios.get(`${instance.url}/api`, {
       params: {
         mode: 'history',
-        apikey: process.env.SABNZBD_API_KEY,
+        apikey: instance.apiKey,
         output: 'json',
         limit: req.query.limit || 50
       }

server/routes/sonarr.js

@@ -4,7 +4,7 @@ const axios = require('axios');
 const router = express.Router();
 const requireAuth = require('../middleware/requireAuth');
 const sanitizeError = require('../utils/sanitizeError');
-const { getWebhookSecret, getSofarrBaseUrl, getSonarrInstances } = require('../utils/config');
+const { getWebhookSecret, getSofarrBaseUrl, getSonarrInstances, getSofarrWebhookBaseUrl } = require('../utils/config');
 
 // Helper to get first Sonarr instance (for notification proxy routes)
 function getFirstSonarrInstance() {
@@ -15,13 +15,41 @@ function getFirstSonarrInstance() {
   return instances[0];
 }
 
+/**
+ * @openapi
+ * /api/sonarr/queue:
+ *   get:
+ *     tags: [Sonarr]
+ *     summary: Get Sonarr queue
+ *     description: Proxy to Sonarr's queue endpoint. Requires authentication and CSRF token.
+ *     security:
+ *       - CookieAuth: []
+ *       - CsrfToken: []
+ *     responses:
+ *       '200':
+ *         description: Queue data from Sonarr
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '500':
+ *         description: Proxy error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
 router.use(requireAuth);
 
 // Get queue
 router.get('/queue', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/queue`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/queue`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -29,11 +57,39 @@ router.get('/queue', async (req, res) => {
   }
 });
 
+/**
+ * @openapi
+ * /api/sonarr/history:
+ *   get:
+ *     tags: [Sonarr]
+ *     summary: Get Sonarr history
+ *     description: Proxy to Sonarr's history endpoint. Requires authentication.
+ *     security:
+ *       - CookieAuth: []
+ *     parameters:
+ *       - name: pageSize
+ *         in: query
+ *         schema:
+ *           type: integer
+ *           default: 50
+ *         description: Number of records per page
+ *     responses:
+ *       '200':
+ *         description: History data from Sonarr
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ */
 // Get history
 router.get('/history', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/history`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY },
+    const response = await axios.get(`${instance.url}/api/v3/history`, {
+      headers: { 'X-Api-Key': instance.apiKey },
       params: { pageSize: req.query.pageSize || 50 }
     });
     res.json(response.data);
@@ -44,9 +100,13 @@ router.get('/history', async (req, res) => {
 
 // Get series details
 router.get('/series/:id', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/series/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/series/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -56,9 +116,13 @@ router.get('/series/:id', async (req, res) => {
 
 // Get all series with tags
 router.get('/series', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/series`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/series`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -66,6 +130,36 @@ router.get('/series', async (req, res) => {
   }
 });
 
+/**
+ * @openapi
+ * /api/sonarr/notifications/sofarr-webhook:
+ *   post:
+ *     tags: [Sonarr]
+ *     summary: Configure Sofarr webhook
+ *     description: One-click setup for Sofarr webhook notification in Sonarr. Requires authentication and CSRF token.
+ *     security:
+ *       - CookieAuth: []
+ *       - CsrfToken: []
+ *     responses:
+ *       '200':
+ *         description: Configured notification
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *       '400':
+ *         description: Missing configuration
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *       '503':
+ *         description: Sonarr not configured
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
 // Notification proxy routes (Phase 3)
 // GET /api/sonarr/notifications - list all notifications
 router.get('/notifications', async (req, res) => {
@@ -86,9 +180,13 @@ router.get('/notifications', async (req, res) => {
 
 // GET /api/sonarr/notifications/:id - get specific notification
 router.get('/notifications/:id', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/notification/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/notification/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -98,9 +196,13 @@ router.get('/notifications/:id', async (req, res) => {
 
 // POST /api/sonarr/notifications - create notification
 router.post('/notifications', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.post(`${process.env.SONARR_URL}/api/v3/notification`, req.body, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.post(`${instance.url}/api/v3/notification`, req.body, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -110,9 +212,13 @@ router.post('/notifications', async (req, res) => {
 
 // PUT /api/sonarr/notifications/:id - update notification
 router.put('/notifications/:id', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.put(`${process.env.SONARR_URL}/api/v3/notification/${req.params.id}`, req.body, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.put(`${instance.url}/api/v3/notification/${req.params.id}`, req.body, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -122,9 +228,13 @@ router.put('/notifications/:id', async (req, res) => {
 
 // DELETE /api/sonarr/notifications/:id - delete notification
 router.delete('/notifications/:id', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.delete(`${process.env.SONARR_URL}/api/v3/notification/${req.params.id}`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.delete(`${instance.url}/api/v3/notification/${req.params.id}`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -155,9 +265,13 @@ router.post('/notifications/test', async (req, res) => {
 
 // GET /api/sonarr/notifications/schema - get notification schema
 router.get('/notifications/schema', async (req, res) => {
+  const instance = getFirstSonarrInstance();
+  if (!instance) {
+    return res.status(503).json({ error: 'Sonarr not configured' });
+  }
   try {
-    const response = await axios.get(`${process.env.SONARR_URL}/api/v3/notification/schema`, {
-      headers: { 'X-Api-Key': process.env.SONARR_API_KEY }
+    const response = await axios.get(`${instance.url}/api/v3/notification/schema`, {
+      headers: { 'X-Api-Key': instance.apiKey }
     });
     res.json(response.data);
   } catch (error) {
@@ -172,17 +286,17 @@ router.post('/notifications/sofarr-webhook', async (req, res) => {
     return res.status(503).json({ error: 'Sonarr not configured' });
   }
   try {
-    const sofarrBaseUrl = getSofarrBaseUrl();
+    const webhookBaseUrl = getSofarrWebhookBaseUrl();
     const webhookSecret = getWebhookSecret();
-
-    if (!sofarrBaseUrl) {
+ 
+    if (!webhookBaseUrl) {
       return res.status(400).json({ error: 'SOFARR_BASE_URL not configured' });
     }
     if (!webhookSecret) {
       return res.status(400).json({ error: 'SOFARR_WEBHOOK_SECRET not configured' });
     }
-
-    const webhookUrl = `${sofarrBaseUrl}/api/webhook/sonarr`;
+ 
+    const webhookUrl = `${webhookBaseUrl}/api/webhook/sonarr`;
 
     // Check if Sofarr webhook already exists
     const listResponse = await axios.get(`${instance.url}/api/v3/notification`, {

server/routes/status.js

@@ -0,0 +1,185 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const express = require('express');
+const router = express.Router();
+const requireAuth = require('../middleware/requireAuth');
+const cache = require('../utils/cache');
+const { getLastPollTimings, POLLING_ENABLED } = require('../utils/poller');
+const { getSonarrInstances, getRadarrInstances, getOmbiInstances } = require('../utils/config');
+const { getGlobalWebhookMetrics } = require('../utils/cache');
+const { checkWebhookConfigured, checkOmbiWebhookConfigured, aggregateMetrics } = require('../services/WebhookStatus');
+const downloadClientRegistry = require('../utils/downloadClients');
+
+/**
+ * @openapi
+ * /api/status/status:
+ *   get:
+ *     tags: [Status]
+ *     summary: Get server status (admin-only)
+ *     description: |
+ *       Admin-only endpoint returning server metrics, cache statistics, polling information,
+ *       and webhook metrics. Used by the admin status panel to monitor sofarr health.
+ *
+ *       **Authentication:** Requires valid `emby_user` cookie (admin only).
+ *
+ *       **Response Structure:**
+ *       - `server`: Uptime, Node version, memory usage
+ *       - `polling`: Polling enabled status, interval, last poll timings
+ *       - `cache`: Cache statistics (item count, sizes, TTLs)
+ *       - `webhooks`: Webhook configuration and metrics for Sonarr/Radarr
+ *
+ *       **Webhook Metrics:**
+ *       - `configured`: Whether webhook is configured in Sonarr/Radarr
+ *       - `eventsReceived`: Total webhook events received
+ *       - `lastWebhookTimestamp`: Last webhook event time
+ *       - `pollsSkipped`: Number of poll cycles skipped due to recent webhook activity
+ *
+ *       **x-integration-notes:** This endpoint is used by the admin status panel to display:
+ *       - Server health and resource usage
+ *       - Polling performance and timing
+ *       - Cache hit rates and sizes
+ *       - Webhook activity and smart polling effectiveness
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Status data
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/StatusResponse'
+ *             example:
+ *               server:
+ *                 uptimeSeconds: 3600
+ *                 nodeVersion: "v22.0.0"
+ *                 memoryUsageMB: 128.5
+ *                 heapUsedMB: 64.2
+ *                 heapTotalMB: 128.0
+ *               polling:
+ *                 enabled: true
+ *                 intervalMs: 5000
+ *                 lastPoll:
+ *                   sabnzbdQueue: 150
+ *                   sonarrQueue: 200
+ *               cache:
+ *                 "poll:sab-queue":
+ *                   size: 2456
+ *                   items: 1
+ *                   ttlRemaining: 12000
+ *               webhooks:
+ *                 sonarr:
+ *                   configured: true
+ *                   eventsReceived: 42
+ *                   lastWebhookTimestamp: "2026-05-21T10:00:00.000Z"
+ *                   pollsSkipped: 15
+ *                 radarr:
+ *                   configured: true
+ *                   eventsReceived: 38
+ *                   lastWebhookTimestamp: "2026-05-21T09:55:00.000Z"
+ *                   pollsSkipped: 12
+ *       '403':
+ *         description: Admin access required
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               error: "Admin access required"
+ *       '500':
+ *         description: Server error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL
+ *         source: |
+ *           curl -X GET http://localhost:3001/api/status/status \
+ *             -b cookies.txt
+ *       - lang: JavaScript
+ *         label: JavaScript (fetch)
+ *         source: |
+ *           const response = await fetch('http://localhost:3001/api/status/status', {
+ *             method: 'GET',
+ *             credentials: 'include'
+ *           });
+ *           const data = await response.json();
+ *           console.log('Uptime:', data.server.uptimeSeconds);
+ */
+router.get('/', requireAuth, async (req, res) => {
+  try {
+    const user = req.user;
+    if (!user.isAdmin) {
+      return res.status(403).json({ error: 'Admin access required' });
+    }
+
+    const cacheStats = cache.getStats();
+    const uptime = process.uptime();
+
+    // Get webhook metrics
+    const webhookMetrics = getGlobalWebhookMetrics();
+
+    // Check webhook configuration for each service
+    const sonarrInstances = getSonarrInstances();
+    const radarrInstances = getRadarrInstances();
+    const ombiInstances = getOmbiInstances();
+
+    const sonarrWebhookConfigured = sonarrInstances.length > 0
+      ? await checkWebhookConfigured(sonarrInstances[0], 'Sonarr')
+      : false;
+    const radarrWebhookConfigured = radarrInstances.length > 0
+      ? await checkWebhookConfigured(radarrInstances[0], 'Radarr')
+      : false;
+    const ombiWebhookConfigured = ombiInstances.length > 0
+      ? await checkOmbiWebhookConfigured(ombiInstances[0])
+      : false;
+
+    // Find Sonarr, Radarr, and Ombi metrics from instances
+    const sonarrMetrics = {};
+    const radarrMetrics = {};
+    const ombiMetrics = {};
+    for (const [url, metrics] of Object.entries(webhookMetrics.instances || {})) {
+      if (url.includes('sonarr')) {
+        sonarrMetrics[url] = metrics;
+      } else if (url.includes('radarr')) {
+        radarrMetrics[url] = metrics;
+      } else if (url.includes('ombi') || (ombiInstances.length > 0 && url === ombiInstances[0].url)) {
+        ombiMetrics[url] = metrics;
+      }
+    }
+
+    res.json({
+      server: {
+        uptimeSeconds: Math.floor(uptime),
+        nodeVersion: process.version,
+        memoryUsageMB: Math.round(process.memoryUsage().rss / 1024 / 1024 * 10) / 10,
+        heapUsedMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024 * 10) / 10,
+        heapTotalMB: Math.round(process.memoryUsage().heapTotal / 1024 / 1024 * 10) / 10
+      },
+      polling: {
+        enabled: POLLING_ENABLED,
+        intervalMs: POLLING_ENABLED ? require('../utils/poller').POLL_INTERVAL : 0,
+        lastPoll: getLastPollTimings()
+      },
+      cache: cacheStats,
+      webhooks: {
+        sonarr: aggregateMetrics(sonarrMetrics, sonarrWebhookConfigured),
+        radarr: aggregateMetrics(radarrMetrics, radarrWebhookConfigured),
+        ombi: aggregateMetrics(ombiMetrics, ombiWebhookConfigured)
+      },
+      // Per-download-client health summary including any lastError captured
+      // since the last successful call. Lets the admin status panel surface
+      // transient failures (auth expiry, RPC blips, etc.) without log scraping.
+      downloadClients: downloadClientRegistry.getAllClients().map(c => ({
+        instanceId: c.getInstanceId(),
+        instanceName: c.name,
+        clientType: c.getClientType(),
+        lastError: typeof c.getLastError === 'function' ? c.getLastError() : null
+      }))
+    });
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to get status', details: err.message });
+  }
+});
+
+module.exports = router;

server/routes/webhook.js

@@ -2,13 +2,72 @@
 const express = require('express');
 const rateLimit = require('express-rate-limit');
 const { logToFile } = require('../utils/logger');
-const { getWebhookSecret, getSonarrInstances, getRadarrInstances } = require('../utils/config');
+const { getWebhookSecret, getSonarrInstances, getRadarrInstances, getOmbiInstances, getSofarrBaseUrl } = require('../utils/config');
 const cache = require('../utils/cache');
 const arrRetrieverRegistry = require('../utils/arrRetrievers');
+const { buildArrQueueCache } = require('../utils/arrQueueHelpers');
 const { pollAllServices, POLL_INTERVAL, POLLING_ENABLED } = require('../utils/poller');
+const { extractRequestedUser } = require('../utils/ombiHelpers');
+const requireAuth = require('../middleware/requireAuth');
 
 const router = express.Router();
 
+/**
+ * @openapi
+ * /api/webhook/config:
+ *   get:
+ *     tags: [Webhook]
+ *     summary: Get webhook configuration status
+ *     description: |
+ *       Returns whether the required webhook configuration (SOFARR_BASE_URL and SOFARR_WEBHOOK_SECRET)
+ *       is properly configured. Used by the webhooks panel to determine if webhooks can be enabled.
+ *
+ *       **Authentication:** Requires valid `emby_user` cookie.
+ *     security:
+ *       - CookieAuth: []
+ *     responses:
+ *       '200':
+ *         description: Webhook configuration status
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 valid:
+ *                   type: boolean
+ *                   description: true if both SOFARR_BASE_URL and SOFARR_WEBHOOK_SECRET are configured
+ *                   example: true
+ *                 missing:
+ *                   type: array
+ *                   items:
+ *                     type: string
+ *                   description: List of missing configuration items
+ *                   example: []
+ *       '401':
+ *         description: Unauthorized
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ */
+router.get('/config', requireAuth, (req, res) => {
+  const sofarrBaseUrl = getSofarrBaseUrl();
+  const webhookSecret = getWebhookSecret();
+  const missing = [];
+
+  if (!sofarrBaseUrl) {
+    missing.push('SOFARR_BASE_URL');
+  }
+  if (!webhookSecret) {
+    missing.push('SOFARR_WEBHOOK_SECRET');
+  }
+
+  res.json({
+    valid: missing.length === 0,
+    missing
+  });
+});
+
 // Dedicated rate limiter for webhook endpoints — stricter than the global API limiter.
 // Sonarr/Radarr send at most one event per action; 60/min per IP is generous.
 // In tests, SKIP_RATE_LIMIT=1 raises the ceiling to effectively unlimited.
@@ -27,7 +86,9 @@ const VALID_EVENT_TYPES = new Set([
   'DownloadFolderImported', 'ImportFailed',
   'EpisodeFileRenamed', 'MovieFileRenamed', 'EpisodeFileRenamedBySeries',
   'Rename', 'SeriesAdd', 'SeriesDelete', 'MovieAdd', 'MovieDelete',
-  'MovieFileDelete', 'Health', 'ApplicationUpdate', 'HealthRestored'
+  'MovieFileDelete', 'Health', 'ApplicationUpdate', 'HealthRestored',
+  // Ombi notification types
+  'NewRequest', 'RequestAvailable', 'RequestApproved', 'RequestDeclined', 'RequestPending', 'RequestProcessing'
 ]);
 
 // Replay protection — cache recently-seen (eventType+instanceName+timestamp) keys.
@@ -43,10 +104,17 @@ function pruneReplayCache() {
   }
 }
 
-function isReplay(eventType, instanceName, eventDate) {
+// Prune the replay cache once per minute
+setInterval(pruneReplayCache, 60 * 1000).unref();
+
+function isReplay(eventType, instanceName, eventDate, contentId) {
   if (!eventDate) return false;
-  pruneReplayCache();
-  const key = `${eventType}:${instanceName || ''}:${eventDate}`;
+  // Content-aware replay key: incorporates downloadId / series.id / movie.id when
+  // available so that distinct events sharing the same `date` (e.g. multiple
+  // Grab events for episodes in a season pack fired in the same second) do not
+  // falsely collide. Falls back to the prior shape when contentId is absent
+  // (e.g. Test events) so existing behaviour is preserved.
+  const key = `${eventType}:${instanceName || ''}:${contentId || ''}:${eventDate}`;
   if (recentEvents.has(key)) return true;
   recentEvents.set(key, Date.now());
   return false;
@@ -71,14 +139,24 @@ const HISTORY_EVENTS = new Set([
   'EpisodeFileRenamedBySeries'
 ]);
 
+// Ombi event types — all Ombi events refresh the requests cache
+const OMBI_EVENTS = new Set([
+  'NewRequest',
+  'RequestAvailable',
+  'RequestApproved',
+  'RequestDeclined',
+  'RequestPending',
+  'RequestProcessing'
+]);
+
 /**
- * Validate webhook secret from the X-Sofarr-Webhook-Secret header
+ * Validate webhook secret from the X-Sofarr-Webhook-Secret header or secret query parameter
  * @param {Object} req - Express request object
  * @returns {boolean} True if secret is valid, false otherwise
  */
 function validateWebhookSecret(req) {
   const expectedSecret = getWebhookSecret();
-  const providedSecret = req.get('X-Sofarr-Webhook-Secret');
+  const providedSecret = req.get('X-Sofarr-Webhook-Secret') || req.query.secret;
 
   if (!expectedSecret) {
     logToFile('[Webhook] WARNING: SOFARR_WEBHOOK_SECRET not configured, rejecting webhook');
@@ -86,7 +164,7 @@ function validateWebhookSecret(req) {
   }
 
   if (!providedSecret) {
-    logToFile('[Webhook] WARNING: Missing X-Sofarr-Webhook-Secret header');
+    logToFile('[Webhook] WARNING: Missing X-Sofarr-Webhook-Secret header or secret query parameter');
     return false;
   }
 
@@ -105,19 +183,20 @@ function validateWebhookSecret(req) {
  *
  * Phase 2: lightweight refresh via arrRetrieverRegistry + cache update + SSE broadcast.
  *
- * @param {string} serviceType - 'sonarr' or 'radarr'
- * @param {string} eventType   - the eventType from the *arr webhook payload
+ * @param {string} serviceType - 'sonarr', 'radarr', or 'ombi'
+ * @param {string} eventType   - the eventType from the webhook payload
  */
-async function processWebhookEvent(serviceType, eventType) {
+async function processWebhookEvent(serviceType, eventType, payload = null) {
   const affectsQueue = QUEUE_EVENTS.has(eventType);
   const affectsHistory = HISTORY_EVENTS.has(eventType);
+  const affectsOmbi = OMBI_EVENTS.has(eventType);
 
-  if (!affectsQueue && !affectsHistory) {
-    logToFile(`[Webhook] Event ${eventType} does not affect queue or history, skipping refresh`);
+  if (!affectsQueue && !affectsHistory && !affectsOmbi) {
+    logToFile(`[Webhook] Event ${eventType} does not affect queue, history, or requests, skipping refresh`);
     return;
   }
 
-  logToFile(`[Webhook] ${serviceType} event "${eventType}" → queue=${affectsQueue}, history=${affectsHistory}`);
+  logToFile(`[Webhook] ${serviceType} event "${eventType}" → queue=${affectsQueue}, history=${affectsHistory}, ombi=${affectsOmbi}`);
 
   // Ensure retrievers are initialized (idempotent)
   await arrRetrieverRegistry.initialize();
@@ -129,17 +208,7 @@ async function processWebhookEvent(serviceType, eventType) {
       const queuesByType = await arrRetrieverRegistry.getQueuesByType();
       const sonarrQueues = queuesByType.sonarr || [];
       cache.set('poll:sonarr-queue', {
-        records: sonarrQueues.flatMap(q => {
-          const inst = sonarrInstances.find(i => i.id === q.instance);
-          const url = inst ? inst.url : null;
-          const key = inst ? inst.apiKey : null;
-          return (q.data.records || []).map(r => {
-            if (r.series) r.series._instanceUrl = url;
-            r._instanceUrl = url;
-            r._instanceKey = key;
-            return r;
-          });
-        })
+        records: buildArrQueueCache(sonarrQueues, sonarrInstances, 'series')
       }, CACHE_TTL);
       logToFile(`[Webhook] Refreshed poll:sonarr-queue (${sonarrQueues.length} instance(s))`);
     }
@@ -159,17 +228,7 @@ async function processWebhookEvent(serviceType, eventType) {
       const queuesByType = await arrRetrieverRegistry.getQueuesByType();
       const radarrQueues = queuesByType.radarr || [];
       cache.set('poll:radarr-queue', {
-        records: radarrQueues.flatMap(q => {
-          const inst = radarrInstances.find(i => i.id === q.instance);
-          const url = inst ? inst.url : null;
-          const key = inst ? inst.apiKey : null;
-          return (q.data.records || []).map(r => {
-            if (r.movie) r.movie._instanceUrl = url;
-            r._instanceUrl = url;
-            r._instanceKey = key;
-            return r;
-          });
-        })
+        records: buildArrQueueCache(radarrQueues, radarrInstances, 'movie')
       }, CACHE_TTL);
       logToFile(`[Webhook] Refreshed poll:radarr-queue (${radarrQueues.length} instance(s))`);
     }
@@ -182,6 +241,73 @@ async function processWebhookEvent(serviceType, eventType) {
       }, CACHE_TTL);
       logToFile(`[Webhook] Refreshed poll:radarr-history (${radarrHistories.length} instance(s))`);
     }
+  } else if (serviceType === 'ombi') {
+    const ombiInstances = getOmbiInstances();
+
+    if (affectsOmbi) {
+      const delayMs = parseInt(process.env.OMBI_WEBHOOK_REFRESH_DELAY_MS, 10);
+      const initialDelay = !isNaN(delayMs) ? delayMs : 2000;
+      logToFile(`[Webhook] Waiting initial delay of ${initialDelay}ms for Ombi webhook synchronization...`);
+      await new Promise(r => setTimeout(r, initialDelay));
+
+      const requestId = payload ? (payload.requestId || payload.RequestId || payload.id || payload.Id) : null;
+      const mediaType = payload ? (payload.type || payload.Type || '').toLowerCase() : null;
+
+      let ombiRequests = { movie: [], tv: [] };
+      let foundAndValid = false;
+      const maxRetries = 3;
+      const retryDelayMs = 1500;
+
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        if (attempt > 1) {
+          logToFile(`[Webhook] Ombi request not found or missing user (attempt ${attempt-1}/${maxRetries}), retrying in ${retryDelayMs}ms...`);
+          await new Promise(r => setTimeout(r, retryDelayMs));
+        }
+
+        ombiRequests = await arrRetrieverRegistry.getOmbiRequests(true);
+
+        if (!requestId) {
+          // If no requestId was provided in payload, we can't search specifically, so just accept the fetch
+          foundAndValid = true;
+          break;
+        }
+
+        // Search in movie or tv lists
+        const targetList = (mediaType === 'tv' || mediaType === 'series') ? (ombiRequests.tv || []) : (ombiRequests.movie || []);
+        // Also check both if mediaType not specified
+        const searchList = mediaType ? targetList : [...(ombiRequests.movie || []), ...(ombiRequests.tv || [])];
+
+        const targetReq = searchList.find(r => r && (r.id === requestId || r.Id === requestId));
+        if (targetReq) {
+          const user = extractRequestedUser(targetReq);
+          if (user) {
+            logToFile(`[Webhook] Verified request ${requestId} has valid user "${user}" on attempt ${attempt}`);
+            foundAndValid = true;
+            break;
+          } else {
+            logToFile(`[Webhook] Found request ${requestId} on attempt ${attempt}, but user extraction was empty.`);
+          }
+        } else {
+          logToFile(`[Webhook] Request ${requestId} not found in retrieved list on attempt ${attempt}.`);
+        }
+      }
+
+      if (!foundAndValid && requestId) {
+        logToFile(`[Webhook] WARNING: Could not verify request ${requestId} with valid user info after ${maxRetries} retries.`);
+        // Try to log the raw target request if we found one
+        ombiRequests = await arrRetrieverRegistry.getOmbiRequests(true);
+        const searchList = [...(ombiRequests.movie || []), ...(ombiRequests.tv || [])];
+        const targetReq = searchList.find(r => r && (r.id === requestId || r.Id === requestId));
+        if (targetReq) {
+          logToFile(`[Webhook] Raw request object where extraction failed: ${JSON.stringify(targetReq)}`);
+        } else {
+          logToFile(`[Webhook] Request ${requestId} was completely absent from Ombi requests list.`);
+        }
+      }
+
+      cache.set('poll:ombi-requests', ombiRequests, CACHE_TTL);
+      logToFile(`[Webhook] Refreshed poll:ombi-requests (${ombiRequests.movie?.length || 0} movies, ${ombiRequests.tv?.length || 0} TV shows)`);
+    }
   }
 
   // Broadcast to all SSE subscribers using the same mechanism poller.js uses.
@@ -217,12 +343,114 @@ function validatePayload(body) {
 }
 
 /**
- * POST /api/webhook/sonarr
- * Receives webhook events from Sonarr instances.
- * Validates the secret, logs the event, refreshes cache, broadcasts SSE, and returns 200.
+ * @openapi
+ * /api/webhook/sonarr:
+ *   post:
+ *     tags: [Webhook]
+ *     summary: Sonarr webhook receiver
+ *     description: |
+ *       Receives webhook events from Sonarr instances. Validates the secret, logs the event,
+ *       refreshes cache, broadcasts SSE, and returns 200 immediately (fire-and-forget processing).
  *
- * Phase 2: integrated with PALDRA cache + SSE for real-time dashboard updates.
- * Phase 6: rate limiting, input validation, replay protection.
+ *       **Authentication:** Requires `X-Sofarr-Webhook-Secret` header or `secret` query parameter matching `SOFARR_WEBHOOK_SECRET`.
+ *       No cookie authentication required (webhooks come from Sonarr, not browsers).
+ *
+ *       **Rate Limiting:** 60 requests per minute per IP.
+ *
+ *       **Validation:**
+ *       - Secret validation via `X-Sofarr-Webhook-Secret` header or `secret` query parameter
+ *       - Payload validation (must be JSON object with eventType, instanceName, date)
+ *       - Event type must be in allowlist (Test, Grab, Download, DownloadFailed, etc.)
+ *       - Replay protection: rejects duplicate events within 5-minute window
+ *
+ *       **Event Classification:**
+ *       - QUEUE_EVENTS (Grab, Download, DownloadFailed, ManualInteractionRequired):
+ *         Refreshes `poll:sonarr-queue` cache
+ *       - HISTORY_EVENTS (DownloadFolderImported, ImportFailed, EpisodeFileRenamed, etc.):
+ *         Refreshes `poll:sonarr-history` cache
+ *       - Informational events (Test, Rename, Health, etc.):
+ *         Logged but no cache refresh
+ *
+ *       **Processing Flow:**
+ *       1. Validate secret → 401 if invalid
+ *       2. Validate payload → 400 if invalid
+ *       3. Check replay cache → 200 with duplicate=true if replay
+ *       4. Update webhook metrics (enables smart polling skip)
+ *       5. Return 200 immediately (don't wait for background processing)
+ *       6. Background: fetch fresh data from Sonarr, update cache, broadcast SSE
+ *
+ *       **x-integration-notes:** Configure Sonarr webhook:
+ *       - URL: `{SOFARR_BASE_URL}/api/webhook/sonarr`
+ *       - Method: POST
+ *       - Header: `X-Sofarr-Webhook-Secret: {SOFARR_WEBHOOK_SECRET}`
+ *       - Events: onGrab, onDownload, onUpgrade, onImport
+ *     security: []
+ *     parameters:
+ *       - name: secret
+ *         in: query
+ *         required: false
+ *         schema:
+ *           type: string
+ *         description: Webhook secret token (alternative to X-Sofarr-Webhook-Secret header)
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/WebhookPayload'
+ *           example:
+ *             eventType: "Grab"
+ *             instanceName: "Main Sonarr"
+ *             date: "2026-05-21T10:00:00.000Z"
+ *     responses:
+ *       '200':
+ *         description: Event received and accepted
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 received:
+ *                   type: boolean
+ *                   example: true
+ *                 duplicate:
+ *                   type: boolean
+ *                   description: True if this event was already processed (replay protection)
+ *                   example: false
+ *             examples:
+ *               newEvent:
+ *                 received: true
+ *                 duplicate: false
+ *               duplicateEvent:
+ *                 received: true
+ *                 duplicate: true
+ *       '401':
+ *         description: Invalid or missing webhook secret
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               error: "Unauthorized"
+ *       '400':
+ *         description: Invalid payload or unknown event type
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             examples:
+ *               invalidPayload:
+ *                 error: "Payload must be a JSON object"
+ *               unknownEventType:
+ *                 error: "Unknown eventType: InvalidEvent"
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL (from Sonarr)
+ *         source: |
+ *           curl -X POST http://sofarr:3001/api/webhook/sonarr \
+ *             -H "Content-Type: application/json" \
+ *             -H "X-Sofarr-Webhook-Secret: your-secret-here" \
+ *             -d '{"eventType":"Grab","instanceName":"Main Sonarr","date":"2026-05-21T10:00:00.000Z"}'
  */
 router.post('/sonarr', webhookLimiter, (req, res) => {
   if (!validateWebhookSecret(req)) {
@@ -237,24 +465,33 @@ router.post('/sonarr', webhookLimiter, (req, res) => {
 
   const { eventType, instanceName, eventDate } = validation;
 
-  if (isReplay(eventType, instanceName, eventDate)) {
-    logToFile(`[Webhook] Sonarr duplicate event ignored: ${eventType} @ ${eventDate}`);
+  const sonarrInstances = getSonarrInstances();
+  const matchedInst = sonarrInstances.find(i => i.name === instanceName || i.id === instanceName);
+  const inst = matchedInst || sonarrInstances[0];
+  if (!matchedInst && instanceName) {
+    logToFile(`[Webhook] Sonarr instanceName "${instanceName}" did not match any configured instance; falling back to first instance (${inst ? inst.name : 'none'})`);
+  }
+  const resolvedInstanceName = inst ? inst.name : instanceName;
+
+  // Content-aware replay key components (Issue #62)
+  const contentId = req.body.downloadId || req.body.series?.id || null;
+
+  // Skip replay protection for Test events
+  if (eventType === "Test") {
+    logToFile(`[Webhook] Sonarr Test event received — skipping replay protection`);
+  } else if (isReplay(eventType, resolvedInstanceName, eventDate, contentId)) {
+    logToFile(`[Webhook] Sonarr duplicate event ignored: ${eventType} @ ${eventDate} (contentId=${contentId || 'none'})`);
     return res.status(200).json({ received: true, duplicate: true });
   }
 
   try {
-    logToFile(`[Webhook] Sonarr event received - Type: ${eventType}, Instance: ${instanceName || 'unknown'}`);
+    logToFile(`[Webhook] Sonarr event received - Type: ${eventType}, Instance: ${resolvedInstanceName || 'unknown'}`);
     logToFile(`[Webhook] Sonarr payload: ${JSON.stringify(req.body)}`);
 
     // Phase 5.1: update webhook metrics for polling optimization
-    // Note: instanceName from webhook is often generic (e.g., "Sonarr"), not the configured name
-    // Update metrics for all Sonarr instances since we can't reliably match
-    const sonarrInstances = getSonarrInstances();
-    if (sonarrInstances.length > 0) {
-      for (const inst of sonarrInstances) {
-        cache.updateWebhookMetrics(inst.url);
-      }
-      logToFile(`[Webhook] Updated metrics for ${sonarrInstances.length} Sonarr instance(s)`);
+    if (inst) {
+      cache.updateWebhookMetrics(inst.url);
+      logToFile(`[Webhook] Updated metrics for Sonarr instance: ${inst.name} (${inst.url})`);
     }
 
     // Phase 2: background cache refresh + SSE broadcast (fire-and-forget)
@@ -270,12 +507,114 @@ router.post('/sonarr', webhookLimiter, (req, res) => {
 });
 
 /**
- * POST /api/webhook/radarr
- * Receives webhook events from Radarr instances.
- * Validates the secret, logs the event, refreshes cache, broadcasts SSE, and returns 200.
+ * @openapi
+ * /api/webhook/radarr:
+ *   post:
+ *     tags: [Webhook]
+ *     summary: Radarr webhook receiver
+ *     description: |
+ *       Receives webhook events from Radarr instances. Validates the secret, logs the event,
+ *       refreshes cache, broadcasts SSE, and returns 200 immediately (fire-and-forget processing).
  *
- * Phase 2: integrated with PALDRA cache + SSE for real-time dashboard updates.
- * Phase 6: rate limiting, input validation, replay protection.
+ *       **Authentication:** Requires `X-Sofarr-Webhook-Secret` header or `secret` query parameter matching `SOFARR_WEBHOOK_SECRET`.
+ *       No cookie authentication required (webhooks come from Radarr, not browsers).
+ *
+ *       **Rate Limiting:** 60 requests per minute per IP.
+ *
+ *       **Validation:**
+ *       - Secret validation via `X-Sofarr-Webhook-Secret` header or `secret` query parameter
+ *       - Payload validation (must be JSON object with eventType, instanceName, date)
+ *       - Event type must be in allowlist (Test, Grab, Download, DownloadFailed, etc.)
+ *       - Replay protection: rejects duplicate events within 5-minute window
+ *
+ *       **Event Classification:**
+ *       - QUEUE_EVENTS (Grab, Download, DownloadFailed, ManualInteractionRequired):
+ *         Refreshes `poll:radarr-queue` cache
+ *       - HISTORY_EVENTS (DownloadFolderImported, ImportFailed, MovieFileRenamed, etc.):
+ *         Refreshes `poll:radarr-history` cache
+ *       - Informational events (Test, Rename, Health, etc.):
+ *         Logged but no cache refresh
+ *
+ *       **Processing Flow:**
+ *       1. Validate secret → 401 if invalid
+ *       2. Validate payload → 400 if invalid
+ *       3. Check replay cache → 200 with duplicate=true if replay
+ *       4. Update webhook metrics (enables smart polling skip)
+ *       5. Return 200 immediately (don't wait for background processing)
+ *       6. Background: fetch fresh data from Radarr, update cache, broadcast SSE
+ *
+ *       **x-integration-notes:** Configure Radarr webhook:
+ *       - URL: `{SOFARR_BASE_URL}/api/webhook/radarr`
+ *       - Method: POST
+ *       - Header: `X-Sofarr-Webhook-Secret: {SOFARR_WEBHOOK_SECRET}`
+ *       - Events: onGrab, onDownload, onUpgrade, onImport
+ *     security: []
+ *     parameters:
+ *       - name: secret
+ *         in: query
+ *         required: false
+ *         schema:
+ *           type: string
+ *         description: Webhook secret token (alternative to X-Sofarr-Webhook-Secret header)
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/WebhookPayload'
+ *           example:
+ *             eventType: "Grab"
+ *             instanceName: "Main Radarr"
+ *             date: "2026-05-21T10:00:00.000Z"
+ *     responses:
+ *       '200':
+ *         description: Event received and accepted
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 received:
+ *                   type: boolean
+ *                   example: true
+ *                 duplicate:
+ *                   type: boolean
+ *                   description: True if this event was already processed (replay protection)
+ *                   example: false
+ *             examples:
+ *               newEvent:
+ *                 received: true
+ *                 duplicate: false
+ *               duplicateEvent:
+ *                 received: true
+ *                 duplicate: true
+ *       '401':
+ *         description: Invalid or missing webhook secret
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               error: "Unauthorized"
+ *       '400':
+ *         description: Invalid payload or unknown event type
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             examples:
+ *               invalidPayload:
+ *                 error: "Payload must be a JSON object"
+ *               unknownEventType:
+ *                 error: "Unknown eventType: InvalidEvent"
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL (from Radarr)
+ *         source: |
+ *           curl -X POST http://sofarr:3001/api/webhook/radarr \
+ *             -H "Content-Type: application/json" \
+ *             -H "X-Sofarr-Webhook-Secret: your-secret-here" \
+ *             -d '{"eventType":"Grab","instanceName":"Main Radarr","date":"2026-05-21T10:00:00.000Z"}'
  */
 router.post('/radarr', webhookLimiter, (req, res) => {
   if (!validateWebhookSecret(req)) {
@@ -290,24 +629,33 @@ router.post('/radarr', webhookLimiter, (req, res) => {
 
   const { eventType, instanceName, eventDate } = validation;
 
-  if (isReplay(eventType, instanceName, eventDate)) {
-    logToFile(`[Webhook] Radarr duplicate event ignored: ${eventType} @ ${eventDate}`);
+  const radarrInstances = getRadarrInstances();
+  const matchedInst = radarrInstances.find(i => i.name === instanceName || i.id === instanceName);
+  const inst = matchedInst || radarrInstances[0];
+  if (!matchedInst && instanceName) {
+    logToFile(`[Webhook] Radarr instanceName "${instanceName}" did not match any configured instance; falling back to first instance (${inst ? inst.name : 'none'})`);
+  }
+  const resolvedInstanceName = inst ? inst.name : instanceName;
+
+  // Content-aware replay key components (Issue #62)
+  const contentId = req.body.downloadId || req.body.movie?.id || null;
+
+  // Skip replay protection for Test events
+  if (eventType === "Test") {
+    logToFile(`[Webhook] Radarr Test event received — skipping replay protection`);
+  } else if (isReplay(eventType, resolvedInstanceName, eventDate, contentId)) {
+    logToFile(`[Webhook] Radarr duplicate event ignored: ${eventType} @ ${eventDate} (contentId=${contentId || 'none'})`);
     return res.status(200).json({ received: true, duplicate: true });
   }
 
   try {
-    logToFile(`[Webhook] Radarr event received - Type: ${eventType}, Instance: ${instanceName || 'unknown'}`);
+    logToFile(`[Webhook] Radarr event received - Type: ${eventType}, Instance: ${resolvedInstanceName || 'unknown'}`);
     logToFile(`[Webhook] Radarr payload: ${JSON.stringify(req.body)}`);
 
     // Phase 5.1: update webhook metrics for polling optimization
-    // Note: instanceName from webhook is often generic (e.g., "Radarr"), not the configured name
-    // Update metrics for all Radarr instances since we can't reliably match
-    const radarrInstances = getRadarrInstances();
-    if (radarrInstances.length > 0) {
-      for (const inst of radarrInstances) {
-        cache.updateWebhookMetrics(inst.url);
-      }
-      logToFile(`[Webhook] Updated metrics for ${radarrInstances.length} Radarr instance(s)`);
+    if (inst) {
+      cache.updateWebhookMetrics(inst.url);
+      logToFile(`[Webhook] Updated metrics for Radarr instance: ${inst.name} (${inst.url})`);
     }
 
     // Phase 2: background cache refresh + SSE broadcast (fire-and-forget)
@@ -322,4 +670,185 @@ router.post('/radarr', webhookLimiter, (req, res) => {
   }
 });
 
+/**
+ * @openapi
+ * /api/webhook/ombi:
+ *   post:
+ *     tags: [Webhook]
+ *     summary: Ombi webhook receiver
+ *     description: |
+ *       Receives webhook events from Ombi instances. Validates the secret, logs the event,
+ *       refreshes cache, broadcasts SSE, and returns 200 immediately (fire-and-forget processing).
+ *
+ *       **Authentication:** Requires `X-Sofarr-Webhook-Secret` header or `secret` query parameter matching `SOFARR_WEBHOOK_SECRET`.
+ *       No cookie authentication required (webhooks come from Ombi, not browsers).
+ *
+ *       **Rate Limiting:** 60 requests per minute per IP.
+ *
+ *       **Validation:**
+ *       - Secret validation via `X-Sofarr-Webhook-Secret` header or `secret` query parameter
+ *       - Payload validation (must be JSON object with notificationType, requestId)
+ *       - Event type must be in allowlist (RequestAvailable, RequestApproved, RequestDeclined, RequestPending, RequestProcessing)
+ *       - Replay protection: rejects duplicate events within 5-minute window
+ *
+ *       **Event Classification:**
+ *       - OMBI_EVENTS (RequestAvailable, RequestApproved, RequestDeclined, RequestPending, RequestProcessing):
+ *         Refreshes `poll:ombi-requests` cache
+ *
+ *       **Processing Flow:**
+ *       1. Validate secret → 401 if invalid
+ *       2. Validate payload → 400 if invalid
+ *       3. Check replay cache → 200 with duplicate=true if replay
+ *       4. Update webhook metrics (enables smart polling skip)
+ *       5. Return 200 immediately (don't wait for background processing)
+ *       6. Background: fetch fresh data from Ombi, update cache, broadcast SSE
+ *
+ *       **x-integration-notes:** Configure Ombi webhook:
+ *       - URL: `{SOFARR_BASE_URL}/api/webhook/ombi?secret={SOFARR_WEBHOOK_SECRET}`
+ *       - Method: POST
+ *       - Application Token: OMBI_API_KEY
+ *     security: []
+ *     parameters:
+ *       - name: secret
+ *         in: query
+ *         required: false
+ *         schema:
+ *           type: string
+ *         description: Webhook secret token (alternative to X-Sofarr-Webhook-Secret header)
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               notificationType:
+ *                 type: string
+ *                 example: "RequestAvailable"
+ *               requestId:
+ *                 type: integer
+ *                 example: 123
+ *               requestedUser:
+ *                 type: string
+ *                 example: "username"
+ *               title:
+ *                 type: string
+ *                 example: "Movie Title"
+ *               type:
+ *                 type: string
+ *                 example: "Movie"
+ *               requestStatus:
+ *                 type: string
+ *                 example: "Available"
+ *           example:
+ *             notificationType: "RequestAvailable"
+ *             requestId: 123
+ *             requestedUser: "username"
+ *             title: "Movie Title"
+ *             type: "Movie"
+ *             requestStatus: "Available"
+ *     responses:
+ *       '200':
+ *         description: Event received and accepted
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 received:
+ *                   type: boolean
+ *                   example: true
+ *                 duplicate:
+ *                   type: boolean
+ *                   description: True if this event was already processed (replay protection)
+ *                   example: false
+ *             examples:
+ *               newEvent:
+ *                 received: true
+ *                 duplicate: false
+ *               duplicateEvent:
+ *                 received: true
+ *                 duplicate: true
+ *       '401':
+ *         description: Invalid or missing webhook secret
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             example:
+ *               error: "Unauthorized"
+ *       '400':
+ *         description: Invalid payload or unknown event type
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/ErrorResponse'
+ *             examples:
+ *               invalidPayload:
+ *                 error: "Payload must be a JSON object"
+ *               unknownEventType:
+ *                 error: "Unknown notificationType: InvalidEvent"
+ *     x-code-samples:
+ *       - lang: curl
+ *         label: cURL (from Ombi)
+ *         source: |
+ *           curl -X POST http://sofarr:3001/api/webhook/ombi \
+ *             -H "Content-Type: application/json" \
+ *             -H "X-Sofarr-Webhook-Secret: your-secret-here" \
+ *             -d '{"notificationType":"RequestAvailable","requestId":123,"requestedUser":"username","title":"Movie Title","type":"Movie","requestStatus":"Available"}'
+ */
+router.post('/ombi', webhookLimiter, (req, res) => {
+  if (!validateWebhookSecret(req)) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  // Ombi uses notificationType instead of eventType. Support PascalCase for .NET apps
+  const notificationType = req.body.notificationType || req.body.NotificationType;
+  const requestId = req.body.requestId || req.body.RequestId;
+  const applicationUrl = req.body.applicationUrl || req.body.ApplicationUrl;
+  
+  const eventType = notificationType || req.body.eventType || req.body.EventType;
+  
+  // Extract username from requestedUser (handles both object and string formats)
+  const username = extractRequestedUser(req.body);
+
+  if (!eventType || !OMBI_EVENTS.has(eventType)) {
+    logToFile(`[Webhook] Ombi payload rejected: invalid or missing notificationType`);
+    return res.status(400).json({ error: 'Invalid or missing notificationType' });
+  }
+
+  // Use applicationUrl as instance identifier for replay protection
+  const instanceName = applicationUrl || 'ombi';
+  const eventDate = req.body.requestedDate || req.body.RequestedDate || new Date().toISOString();
+  const contentId = requestId || null;
+
+  if (isReplay(eventType, instanceName, eventDate, contentId)) {
+    logToFile(`[Webhook] Ombi duplicate event ignored: ${eventType} requestId=${requestId}`);
+    return res.status(200).json({ received: true, duplicate: true });
+  }
+
+  try {
+    logToFile(`[Webhook] Ombi event received - Type: ${eventType}, RequestId: ${requestId}, User: ${username}`);
+    logToFile(`[Webhook] Ombi payload: ${JSON.stringify(req.body)}`);
+
+    // Update webhook metrics for polling optimization
+    const ombiInstances = getOmbiInstances();
+    const inst = ombiInstances[0]; // Use first Ombi instance
+    if (inst) {
+      cache.updateWebhookMetrics(inst.url);
+      logToFile(`[Webhook] Updated metrics for Ombi instance: ${inst.name} (${inst.url})`);
+    }
+
+    // Background cache refresh + SSE broadcast (fire-and-forget)
+    processWebhookEvent('ombi', eventType, req.body).catch(err => {
+      logToFile(`[Webhook] Ombi background refresh error: ${err.message}`);
+    });
+
+    res.status(200).json({ received: true });
+  } catch (error) {
+    logToFile(`[Webhook] Ombi error: ${error.message}`);
+    res.status(200).json({ received: true });
+  }
+});
+
 module.exports = router;

server/services/DownloadAssembler.js

@@ -0,0 +1,123 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+// Helper function to extract poster/cover art URL from a movie or series object
+function getCoverArt(item) {
+  if (!item || !item.images) return null;
+  const poster = item.images.find(img => img.coverType === 'poster');
+  if (poster) return poster.remoteUrl || poster.url || null;
+  // Fallback to fanart if no poster
+  const fanart = item.images.find(img => img.coverType === 'fanart');
+  return fanart ? (fanart.remoteUrl || fanart.url || null) : null;
+}
+
+// Extract import issues from a Sonarr/Radarr queue record
+function getImportIssues(queueRecord) {
+  if (!queueRecord) return null;
+  const state = queueRecord.trackedDownloadState;
+  const status = queueRecord.trackedDownloadStatus;
+  if (state !== 'importPending' && status !== 'warning' && status !== 'error') return null;
+  const messages = [];
+  if (queueRecord.statusMessages && queueRecord.statusMessages.length > 0) {
+    for (const sm of queueRecord.statusMessages) {
+      if (sm.messages && sm.messages.length > 0) {
+        messages.push(...sm.messages);
+      } else if (sm.title) {
+        messages.push(sm.title);
+      }
+    }
+  }
+  if (queueRecord.errorMessage) {
+    messages.push(queueRecord.errorMessage);
+  }
+  if (messages.length === 0) return null;
+  return messages;
+}
+
+// Helper to build Sonarr web UI link for a series
+function getSonarrLink(series) {
+  if (!series || !series._instanceUrl || !series.titleSlug) return null;
+  return `${series._instanceUrl}/series/${series.titleSlug}`;
+}
+
+// Helper to build Radarr web UI link for a movie
+function getRadarrLink(movie) {
+  if (!movie || !movie._instanceUrl || !movie.titleSlug) return null;
+  return `${movie._instanceUrl}/movie/${movie.titleSlug}`;
+}
+
+// Helper to build Ombi details link using TMDB ID from *arr media object
+// Movies: {ombiBaseUrl}/details/movie/{tmdbId}
+// TV:     {ombiBaseUrl}/details/tv/{tmdbId}
+function getOmbiDetailsLink(mediaObj, type, ombiBaseUrl) {
+  if (!ombiBaseUrl || !mediaObj) return null;
+  const tmdbId = mediaObj.tmdbId;
+  if (!tmdbId) return null;
+  if (type === 'series') {
+    return `${ombiBaseUrl}/details/tv/${tmdbId}`;
+  } else if (type === 'movie') {
+    return `${ombiBaseUrl}/details/movie/${tmdbId}`;
+  }
+  return null;
+}
+
+// Determine if a download can be blocklisted by the current user
+// Admins: always true (they have arrQueueId)
+// Non-admins: true if importIssues OR (torrent >1h old AND availability<100%)
+function canBlocklist(download, isAdmin) {
+  if (isAdmin) return true;
+  if (download.importIssues && download.importIssues.length > 0) return true;
+  if (download.qbittorrent && download.addedOn && download.availability) {
+    const oneHourAgo = Date.now() - 3600000; // 1 hour in ms
+    const addedOn = new Date(download.addedOn).getTime();
+    const isOldEnough = addedOn < oneHourAgo;
+    const availability = parseFloat(download.availability);
+    const isLowAvailability = availability < 100;
+    return isOldEnough && isLowAvailability;
+  }
+  return false;
+}
+
+// Extract episode info from a Sonarr queue/history record.
+// Returns { season, episode, title } or null if data is missing.
+function extractEpisode(record) {
+  if (!record) return null;
+  const ep = record.episode || {};
+  const s = ep.seasonNumber != null ? ep.seasonNumber : record.seasonNumber;
+  const e = ep.episodeNumber != null ? ep.episodeNumber : record.episodeNumber;
+  if (s == null || e == null) return null;
+  const title = ep.title || null;
+  return { season: s, episode: e, title };
+}
+
+// Find all episodes associated with a download by matching all queue/history records
+// that share the same title string.  Returns sorted array of { season, episode, title }.
+function gatherEpisodes(titleLower, sonarrRecords) {
+  const episodes = [];
+  const seen = new Set();
+  for (const r of sonarrRecords) {
+    const rTitle = (r.title || r.sourceTitle || '').toLowerCase();
+    if (rTitle && (rTitle.includes(titleLower) || titleLower.includes(rTitle))) {
+      const ep = extractEpisode(r);
+      if (ep) {
+        const key = `${ep.season}x${ep.episode}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          episodes.push(ep);
+        }
+      }
+    }
+  }
+  episodes.sort((a, b) => a.season - b.season || a.episode - b.episode);
+  return episodes;
+}
+
+module.exports = {
+  getCoverArt,
+  getImportIssues,
+  getSonarrLink,
+  getRadarrLink,
+  getOmbiDetailsLink,
+  canBlocklist,
+  extractEpisode,
+  gatherEpisodes
+};

server/services/DownloadBuilder.js

@@ -0,0 +1,130 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+/**
+ * DownloadBuilder - Aggregates and matches download data from multiple sources.
+ * This service processes cached data from SABnzbd, qBittorrent, Sonarr, and Radarr to build
+ * a unified view of downloads for each user, matching downloads to media metadata via tags.
+ */
+
+const DownloadMatcher = require('./DownloadMatcher');
+
+/**
+ * Builds a unified list of downloads for a user from multiple download clients.
+ * Matches SABnzbd and qBittorrent downloads to Sonarr/Radarr activity using tags.
+ * @param {Object} cacheSnapshot - Cached data from all services
+ * @param {Object} options - User context and metadata maps
+ * @param {string} options.username - Lowercase username for tag matching
+ * @param {string} options.usernameSanitized - Original username
+ * @param {boolean} options.isAdmin - Whether user is admin
+ * @param {boolean} options.showAll - Whether to show all users' downloads
+ * @param {Map} options.seriesMap - Map of seriesId to series object
+ * @param {Map} options.moviesMap - Map of movieId to movie object
+ * @param {Map} options.sonarrTagMap - Map of Sonarr tag IDs to labels
+ * @param {Map} options.radarrTagMap - Map of Radarr tag IDs to labels
+ * @param {Map} options.embyUserMap - Map of Emby users for admin view
+ * @param {OmbiRetriever} options.ombiRetriever - Ombi data retriever instance (optional)
+ * @param {string} options.ombiBaseUrl - Ombi base URL for link generation (optional)
+ * @returns {Array} Array of download objects for the user
+ */
+async function buildUserDownloads(cacheSnapshot, { username, usernameSanitized, isAdmin, showAll, seriesMap, moviesMap, sonarrTagMap, radarrTagMap, embyUserMap, ombiRetriever, ombiBaseUrl }) {
+  // Input validation
+  if (!cacheSnapshot || typeof cacheSnapshot !== 'object') {
+    console.error('[DownloadBuilder] Invalid cacheSnapshot provided');
+    return [];
+  }
+
+  try {
+    // Handle null/undefined cache data
+  const sabnzbdQueue = cacheSnapshot.sabnzbdQueue || { data: { queue: { slots: [] } } };
+  const sabnzbdHistory = cacheSnapshot.sabnzbdHistory || { data: { history: { slots: [] } } };
+  const sonarrQueue = cacheSnapshot.sonarrQueue || { data: { records: [] } };
+  const sonarrHistory = cacheSnapshot.sonarrHistory || { data: { records: [] } };
+  const radarrQueue = cacheSnapshot.radarrQueue || { data: { records: [] } };
+  const radarrHistory = cacheSnapshot.radarrHistory || { data: { records: [] } };
+  const qbittorrentTorrents = cacheSnapshot.qbittorrentTorrents || [];
+
+  // Get queue status for SABnzbd
+  const queueStatus = sabnzbdQueue.data?.queue?.status || null;
+  const queueSpeed = sabnzbdQueue.data?.queue?.speed || null;
+  const queueKbpersec = sabnzbdQueue.data?.queue?.kbpersec || null;
+
+  // Build context for matching functions
+  const context = {
+    sonarrQueueRecords: sonarrQueue.data?.records || [],
+    sonarrHistoryRecords: sonarrHistory.data?.records || [],
+    radarrQueueRecords: radarrQueue.data?.records || [],
+    radarrHistoryRecords: radarrHistory.data?.records || [],
+    seriesMap: seriesMap || new Map(),
+    moviesMap: moviesMap || new Map(),
+    sonarrTagMap: sonarrTagMap || new Map(),
+    radarrTagMap: radarrTagMap || new Map(),
+    username,
+    isAdmin,
+    showAll,
+    embyUserMap: embyUserMap || new Map(),
+    queueStatus,
+    queueSpeed,
+    queueKbpersec,
+    ombiRetriever,
+    ombiBaseUrl
+  };
+
+  // Match all download sources
+  const userDownloads = [];
+  const seenDownloadKeys = new Set();
+  const matchedArrQueueIds = new Set();
+  
+  if (sabnzbdQueue.data?.queue?.slots) {
+    const sabMatches = await DownloadMatcher.matchSabSlots(sabnzbdQueue.data.queue.slots, context);
+    for (const dl of sabMatches) {
+      const key = `${dl.type}:${dl.title}`;
+      if (!seenDownloadKeys.has(key)) {
+        seenDownloadKeys.add(key);
+        userDownloads.push(dl);
+        if (dl.arrQueueId) matchedArrQueueIds.add(dl.arrQueueId);
+      }
+    }
+  }
+
+  if (sabnzbdHistory.data?.history?.slots) {
+    const sabHistoryMatches = await DownloadMatcher.matchSabHistory(sabnzbdHistory.data.history.slots, context);
+    for (const dl of sabHistoryMatches) {
+      const key = `${dl.type}:${dl.title}`;
+      if (!seenDownloadKeys.has(key)) {
+        seenDownloadKeys.add(key);
+        userDownloads.push(dl);
+        if (dl.arrQueueId) matchedArrQueueIds.add(dl.arrQueueId);
+      }
+    }
+  }
+
+  const torrentMatches = await DownloadMatcher.matchTorrents(qbittorrentTorrents, context);
+  for (const dl of torrentMatches) {
+    const key = `${dl.type}:${dl.title}`;
+    if (!seenDownloadKeys.has(key)) {
+      seenDownloadKeys.add(key);
+      userDownloads.push(dl);
+      if (dl.arrQueueId) matchedArrQueueIds.add(dl.arrQueueId);
+    }
+  }
+
+  // Phase 2: Match orphaned records that have no active download client counterpart
+  const orphanedMatches = await DownloadMatcher.matchOrphanedArrRecords(matchedArrQueueIds, context);
+  for (const dl of orphanedMatches) {
+    const key = `${dl.type}:${dl.title}`;
+    if (!seenDownloadKeys.has(key)) {
+      seenDownloadKeys.add(key);
+      userDownloads.push(dl);
+    }
+  }
+
+    return userDownloads;
+  } catch (error) {
+    console.error('[DownloadBuilder] Error building user downloads:', error.message);
+    return [];
+  }
+}
+
+module.exports = {
+  buildUserDownloads
+};

server/services/DownloadMatcher.js

@@ -0,0 +1,615 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+
+/**
+ * DownloadMatcher - Matches download client data to Sonarr/Radarr activity.
+ * Contains logic for matching SABnzbd slots and qBittorrent torrents to media metadata
+ * via download IDs and title matching.
+ */
+
+const { mapTorrentToDownload } = require('../utils/qbittorrent');
+const TagMatcher = require('./TagMatcher');
+const DownloadAssembler = require('./DownloadAssembler');
+const { logToFile } = require('../utils/logger');
+
+const logger = {
+  debug: (msg) => logToFile(`[DEBUG] ${msg}`)
+};
+
+/**
+ * Normalizes a title by lowercase conversion and replacing periods/underscores/dashes with spaces.
+ * @param {string} str - The title to normalize
+ * @returns {string} Normalized title
+ */
+function normalizeTitle(str) {
+  if (!str) return '';
+  return String(str)
+    .toLowerCase()
+    .replace(/\./g, ' ')
+    .replace(/[\-_]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/**
+ * Compares a download client item name with a *arr title by checking both raw
+ * and normalized (dots/dashes/underscores to spaces) forms bidirectionally.
+ * Only logs on title fallback matches (when isFallback=true) to keep logs clean.
+ */
+function titleMatches(clientName, arrTitle, { isFallback = true, caller = 'DownloadMatcher' } = {}) {
+  if (!clientName || !arrTitle) return false;
+  const a = clientName.toLowerCase();
+  const b = arrTitle.toLowerCase();
+  const aNorm = normalizeTitle(clientName);
+  const bNorm = normalizeTitle(arrTitle);
+  
+  const matched = a.includes(b) || b.includes(a) ||
+                  aNorm.includes(bNorm) || bNorm.includes(aNorm) ||
+                  aNorm.includes(b) || b.includes(aNorm) ||
+                  a.includes(bNorm) || bNorm.includes(a);
+
+  if (matched && isFallback) {
+    logger.debug(`[DownloadMatcher] Title fallback match in ${caller} after normalization: "${clientName}" <-> "${arrTitle}"`);
+  }
+  return matched;
+}
+
+/**
+ * All callers (matchers + orphan path) must supply client, instanceId, and instanceName via options.
+ * Defaults exist only as a last-resort safety net.
+ *
+ * @example
+ * buildArrDownload(sonarrMatch, context, { client: 'sabnzbd', instanceId: 'sabnzbd-default', instanceName: 'SABnzbd' })
+ */
+function buildArrDownload(record, context, options = {}) {
+  const {
+    seriesMap,
+    moviesMap,
+    sonarrTagMap,
+    radarrTagMap,
+    username,
+    isAdmin,
+    showAll,
+    embyUserMap
+  } = context;
+
+  // Detect if sonarr or radarr record
+  const isSeries = record.seriesId !== undefined || options.arrType === 'sonarr';
+  const mediaMap = isSeries ? seriesMap : moviesMap;
+  const tagMap = isSeries ? sonarrTagMap : radarrTagMap;
+  const mediaId = isSeries ? record.seriesId : record.movieId;
+  
+  const media = mediaMap.get(mediaId) || record.series || record.movie;
+  if (!media) return null;
+
+  // Tag-based user filtering
+  const allTags = TagMatcher.extractAllTags(media.tags, tagMap);
+  const matchedUserTag = TagMatcher.extractUserTag(media.tags, tagMap, username);
+  if (!showAll && !matchedUserTag) return null;
+
+  // Safer default progress of 0 for items that haven't started yet
+  const progress = options.progress !== undefined ? options.progress : 0;
+
+  const dlObj = {
+    type: isSeries ? 'series' : 'movie',
+    title: options.title || record.title || record.sourceTitle,
+    coverArt: DownloadAssembler.getCoverArt(media),
+    status: options.status || record.status || 'Unknown',
+    progress,
+    mb: options.mb !== undefined ? options.mb : (record.size ? Math.round(record.size / 1024 / 1024) : 0),
+    size: options.size !== undefined ? options.size : (record.size || 0),
+    completedAt: options.completedAt || record.completed_time || null,
+    allTags,
+    matchedUserTag: matchedUserTag || null,
+    tagBadges: showAll ? TagMatcher.buildTagBadges(allTags, embyUserMap) : undefined,
+    // Strict neutral defaults to avoid incorrect SABnzbd-centric data
+    client: options.client || 'orphaned',
+    instanceId: options.instanceId || 'orphaned',
+    instanceName: options.instanceName || 'Unknown',
+    ...options.overrides
+  };
+
+  if (isSeries) {
+    dlObj.seriesName = media.title;
+    dlObj.episodes = options.episodes || [];
+  } else {
+    dlObj.movieName = media.title;
+    dlObj.movieInfo = record;
+  }
+
+  const issues = DownloadAssembler.getImportIssues(record);
+  if (issues) dlObj.importIssues = issues;
+
+  dlObj.arrQueueId = record.id;
+  dlObj.arrType = isSeries ? 'sonarr' : 'radarr';
+  dlObj.arrInstanceUrl = record._instanceUrl || null;
+  dlObj.arrContentId = record.episodeId || record.movieId || null;
+  dlObj.arrContentIds = record.episodeIds || null;
+  dlObj.arrSeriesId = record.seriesId || null;
+  dlObj.arrContentType = isSeries ? 'episode' : 'movie';
+  
+  // Use correct blocklist determination
+  dlObj.canBlocklist = DownloadAssembler.canBlocklist(dlObj, isAdmin);
+
+  if (isAdmin) {
+    dlObj.downloadPath = options.downloadPath || null;
+    dlObj.targetPath = media.path || null;
+    dlObj.arrInstanceKey = record._instanceKey || null;
+    dlObj.arrLink = isSeries 
+      ? DownloadAssembler.getSonarrLink(media)
+      : DownloadAssembler.getRadarrLink(media);
+  }
+
+  addOmbiMatching(dlObj, media, context);
+
+  return dlObj;
+}
+
+/**
+ * Builds a Map of series metadata from Sonarr queue and history records.
+ * @param {Array} queueRecords - Sonarr queue records
+ * @param {Array} historyRecords - Sonarr history records
+ * @returns {Map} Map of seriesId to series object
+ */
+function buildSeriesMapFromRecords(queueRecords, historyRecords) {
+  const seriesMap = new Map();
+  for (const r of queueRecords) {
+    if (r.series && r.seriesId) seriesMap.set(r.seriesId, r.series);
+  }
+  for (const r of historyRecords) {
+    if (r.series && r.seriesId && !seriesMap.has(r.seriesId)) seriesMap.set(r.seriesId, r.series);
+  }
+  return seriesMap;
+}
+
+/**
+ * Builds a Map of movie metadata from Radarr queue and history records.
+ * @param {Array} queueRecords - Radarr queue records
+ * @param {Array} historyRecords - Radarr history records
+ * @returns {Map} Map of movieId to movie object
+ */
+function buildMoviesMapFromRecords(queueRecords, historyRecords) {
+  const moviesMap = new Map();
+  for (const r of queueRecords) {
+    if (r.movie && r.movieId) moviesMap.set(r.movieId, r.movie);
+  }
+  for (const r of historyRecords) {
+    if (r.movie && r.movieId && !moviesMap.has(r.movieId)) moviesMap.set(r.movieId, r.movie);
+  }
+  return moviesMap;
+}
+
+/**
+ * Adds an Ombi details link to a download object using the TMDB ID from the *arr media object.
+ * No Ombi API call is required — the link is built directly from the TMDB ID.
+ * @param {Object} downloadObj - Download object to enhance
+ * @param {Object} seriesOrMovie - Series or movie object from Sonarr/Radarr
+ * @param {Object} context - Context containing ombiBaseUrl
+ */
+function addOmbiMatching(downloadObj, seriesOrMovie, context) {
+  const { ombiBaseUrl } = context;
+  const link = DownloadAssembler.getOmbiDetailsLink(seriesOrMovie, downloadObj.type, ombiBaseUrl);
+  if (link) {
+    downloadObj.ombiLink = link;
+    downloadObj.ombiTooltip = 'View in Ombi';
+  }
+}
+
+/**
+ * Determines the status and speed for a SABnzbd slot based on queue state.
+ * @param {Object} slot - SABnzbd queue slot
+ * @param {string} queueStatus - Overall queue status (e.g., 'Paused')
+ * @param {string} queueSpeed - Queue speed string
+ * @param {string} queueKbpersec - Queue speed in KB/s
+ * @returns {Object} Object with status and speed properties
+ */
+function getSlotStatusAndSpeed(slot, queueStatus, queueSpeed, queueKbpersec) {
+  if (queueStatus === 'Paused') {
+    return { status: 'Paused', speed: '0' };
+  }
+  return {
+    status: slot.status || 'Unknown',
+    speed: queueSpeed || queueKbpersec || '0'
+  };
+}
+
+/**
+ * Matches SABnzbd queue slots to Sonarr/Radarr activity using download IDs and title matching.
+ * @param {Array} slots - SABnzbd queue slots
+ * @param {Object} context - Matching context with records, maps, and user info
+ * @returns {Array} Array of matched download objects
+ */
+async function matchSabSlots(slots, context) {
+  const {
+    sonarrQueueRecords,
+    sonarrHistoryRecords,
+    radarrQueueRecords,
+    radarrHistoryRecords,
+    queueStatus,
+    queueSpeed,
+    queueKbpersec
+  } = context;
+
+  const matched = [];
+  for (const slot of slots) {
+    const nzbName = slot.filename || slot.nzbname;
+    if (!nzbName) continue;
+
+    const slotState = getSlotStatusAndSpeed(slot, queueStatus, queueSpeed, queueKbpersec);
+    const nzbNameLower = nzbName.toLowerCase();
+
+    // Try to match by downloadId first (most reliable)
+    const sabDownloadId = slot.nzo_id || slot.id;
+    let sonarrMatch = sabDownloadId ? sonarrQueueRecords.find(r => r.downloadId === sabDownloadId) : null;
+    let radarrMatch = sabDownloadId ? radarrQueueRecords.find(r => r.downloadId === sabDownloadId) : null;
+
+    // Also check HISTORY by downloadId
+    if (!sonarrMatch && sabDownloadId) {
+      sonarrMatch = sonarrHistoryRecords.find(r => r.downloadId === sabDownloadId);
+    }
+    if (!radarrMatch && sabDownloadId) {
+      radarrMatch = radarrHistoryRecords.find(r => r.downloadId === sabDownloadId);
+    }
+
+    // Fallback: Check by title matching
+    if (!sonarrMatch) {
+      sonarrMatch = sonarrQueueRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabSlots' });
+      });
+    }
+    if (!radarrMatch) {
+      radarrMatch = radarrQueueRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabSlots' });
+      });
+    }
+
+    // Also check HISTORY (completed downloads) if no queue match
+    if (!sonarrMatch) {
+      sonarrMatch = sonarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabSlots' });
+      });
+    }
+    if (!radarrMatch) {
+      radarrMatch = radarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabSlots' });
+      });
+    }
+
+    // Progress calculation
+    const mbValue = slot.mb !== undefined && slot.mb !== null ? parseFloat(slot.mb) : 0;
+    const mbLeftValue = (slot.mbleft !== undefined && slot.mbleft !== null) || (slot.mbmissing !== undefined && slot.mbmissing !== null)
+      ? parseFloat(slot.mbleft || slot.mbmissing)
+      : 0;
+    const progress = mbValue > 0 ? ((mbValue - mbLeftValue) / mbValue) * 100 : 0;
+
+    const commonOptions = {
+      title: nzbName,
+      status: slotState.status,
+      progress: Math.round(progress),
+      mb: slot.mb,
+      size: Math.round(slot.mb * 1024 * 1024),
+      client: 'sabnzbd',
+      instanceId: slot.instanceId || 'sabnzbd-default',
+      instanceName: slot.instanceName || 'SABnzbd',
+      downloadPath: slot.storage || null,
+      overrides: {
+        mbmissing: slot.mbleft,
+        speed: Math.round((slot.kbpersec || 0) * 1024),
+        eta: slot.timeleft
+      }
+    };
+
+    if (sonarrMatch && sonarrMatch.seriesId) {
+      const dlObj = buildArrDownload(sonarrMatch, context, {
+        ...commonOptions,
+        arrType: 'sonarr',
+        episodes: DownloadAssembler.gatherEpisodes(nzbNameLower, sonarrQueueRecords)
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+
+    if (radarrMatch && radarrMatch.movieId) {
+      const dlObj = buildArrDownload(radarrMatch, context, {
+        ...commonOptions,
+        arrType: 'radarr'
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+  }
+  return matched;
+}
+
+/**
+ * Matches SABnzbd history slots to Sonarr/Radarr activity using title matching.
+ * @param {Array} slots - SABnzbd history slots
+ * @param {Object} context - Matching context with records, maps, and user info
+ * @returns {Array} Array of matched download objects
+ */
+async function matchSabHistory(slots, context) {
+  const {
+    sonarrQueueRecords,
+    sonarrHistoryRecords,
+    radarrQueueRecords,
+    radarrHistoryRecords
+  } = context;
+
+  const matched = [];
+  for (const slot of slots) {
+    const nzbName = slot.name || slot.nzb_name || slot.nzbname;
+    if (!nzbName) continue;
+    const nzbNameLower = nzbName.toLowerCase();
+
+    // Try to match by downloadId (nzo_id or slot ID) first (most reliable)
+    const sabDownloadId = slot.nzo_id || slot.id;
+    const matchesSabId = (r) => {
+      const dl = r && r.downloadId;
+      if (!dl || !sabDownloadId) return false;
+      return String(dl).toLowerCase() === String(sabDownloadId).toLowerCase();
+    };
+
+    let sonarrMatch = sabDownloadId ? sonarrHistoryRecords.find(matchesSabId) : null;
+    let radarrMatch = sabDownloadId ? radarrHistoryRecords.find(matchesSabId) : null;
+
+    // Dual-lookup: also try against active queue records (history slot may still be in *arr queue)
+    if (!sonarrMatch && sabDownloadId) {
+      sonarrMatch = sonarrQueueRecords.find(matchesSabId);
+    }
+    if (!radarrMatch && sabDownloadId) {
+      radarrMatch = radarrQueueRecords.find(matchesSabId);
+    }
+
+    // Fallback: Check by title matching
+    if (!sonarrMatch) {
+      sonarrMatch = sonarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabHistory' });
+      });
+    }
+    if (!radarrMatch) {
+      radarrMatch = radarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(nzbName, rTitle, { isFallback: true, caller: 'matchSabHistory' });
+      });
+    }
+
+    const commonOptions = {
+      title: nzbName,
+      status: slot.status || 'Completed',
+      progress: 100, // History items are completed
+      mb: slot.mb,
+      size: Math.round((slot.mb || 0) * 1024 * 1024),
+      completedAt: slot.completed_time,
+      client: 'sabnzbd',
+      instanceId: slot.instanceId || 'sabnzbd-default',
+      instanceName: slot.instanceName || 'SABnzbd',
+      downloadPath: slot.storage || null
+    };
+
+    if (sonarrMatch && sonarrMatch.seriesId) {
+      const dlObj = buildArrDownload(sonarrMatch, context, {
+        ...commonOptions,
+        arrType: 'sonarr',
+        episodes: DownloadAssembler.gatherEpisodes(nzbNameLower, sonarrHistoryRecords)
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+
+    if (radarrMatch && radarrMatch.movieId) {
+      const dlObj = buildArrDownload(radarrMatch, context, {
+        ...commonOptions,
+        arrType: 'radarr'
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+  }
+  return matched;
+}
+
+/**
+ * Matches qBittorrent torrents to Sonarr/Radarr activity using title matching.
+ * @param {Array} torrents - qBittorrent torrent list
+ * @param {Object} context - Matching context with records, maps, and user info
+ * @returns {Array} Array of matched download objects
+ */
+async function matchTorrents(torrents, context) {
+  const {
+    sonarrQueueRecords,
+    sonarrHistoryRecords,
+    radarrQueueRecords,
+    radarrHistoryRecords
+  } = context;
+
+  const matched = [];
+  for (const torrent of torrents) {
+    const torrentName = torrent.name || '';
+    if (!torrentName) continue;
+    const torrentNameLower = torrentName.toLowerCase();
+
+    // Hash-first matching (Issue #65)
+    const torrentHash = torrent?.hash || torrent?.hashString || null;
+    const hashLower = torrentHash ? String(torrentHash).toLowerCase() : null;
+    const matchesByHash = (r) => {
+      const dl = r && r.downloadId;
+      if (!dl || !hashLower) return false;
+      return String(dl).toLowerCase() === hashLower;
+    };
+
+    let sonarrMatch = hashLower ? sonarrQueueRecords.find(matchesByHash) : null;
+    let radarrMatch = hashLower ? radarrQueueRecords.find(matchesByHash) : null;
+
+    // Fallback: Check by title matching
+    if (!sonarrMatch) {
+      sonarrMatch = sonarrQueueRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(torrentName, rTitle, { isFallback: true, caller: 'matchTorrents' });
+      });
+    }
+    if (!radarrMatch) {
+      radarrMatch = radarrQueueRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(torrentName, rTitle, { isFallback: true, caller: 'matchTorrents' });
+      });
+    }
+
+    // Fallback to history matching
+    let sonarrHistoryMatch = hashLower ? sonarrHistoryRecords.find(matchesByHash) : null;
+    let radarrHistoryMatch = hashLower ? radarrHistoryRecords.find(matchesByHash) : null;
+
+    if (!sonarrHistoryMatch) {
+      sonarrHistoryMatch = sonarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(torrentName, rTitle, { isFallback: true, caller: 'matchTorrents' });
+      });
+    }
+    if (!radarrHistoryMatch) {
+      radarrHistoryMatch = radarrHistoryRecords.find(r => {
+        const rTitle = r.title || r.sourceTitle;
+        return rTitle && titleMatches(torrentName, rTitle, { isFallback: true, caller: 'matchTorrents' });
+      });
+    }
+
+    // Helper options for torrent mapping
+    const download = mapTorrentToDownload(torrent);
+    const progress = parseFloat(download.progress) || torrent.progress || 0;
+    const speed = download.rawSpeed || torrent.dlspeed || 0;
+
+    const commonOptions = {
+      title: torrentName,
+      status: download.status || torrent.status || 'Downloading',
+      progress: Math.round(progress),
+      mb: download.size ? Math.round(download.size / 1024 / 1024) : 0,
+      size: download.size || torrent.size || 0,
+      client: download.client || 'qbittorrent',
+      instanceId: torrent.instanceId || download.instanceId || 'qbittorrent-default',
+      instanceName: torrent.instanceName || download.instanceName || 'qBittorrent',
+      downloadPath: download.savePath || torrent.savePath || null,
+      overrides: {
+        id: download.hash || torrent.hash,
+        speed,
+        eta: torrent.eta,
+        seeds: torrent.seeds,
+        peers: torrent.peers,
+        availability: torrent.availability,
+        addedOn: torrent.addedOn,
+        qbittorrent: true
+      }
+    };
+
+    if (sonarrMatch && sonarrMatch.seriesId) {
+      const dlObj = buildArrDownload(sonarrMatch, context, {
+        ...commonOptions,
+        arrType: 'sonarr',
+        episodes: DownloadAssembler.gatherEpisodes(torrentNameLower, sonarrQueueRecords)
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+
+    if (radarrMatch && radarrMatch.movieId) {
+      const dlObj = buildArrDownload(radarrMatch, context, {
+        ...commonOptions,
+        arrType: 'radarr'
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+
+    if (sonarrHistoryMatch && sonarrHistoryMatch.seriesId) {
+      const dlObj = buildArrDownload(sonarrHistoryMatch, context, {
+        ...commonOptions,
+        arrType: 'sonarr',
+        progress: 100, // completed
+        episodes: DownloadAssembler.gatherEpisodes(torrentNameLower, sonarrHistoryRecords)
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+
+    if (radarrHistoryMatch && radarrHistoryMatch.movieId) {
+      const dlObj = buildArrDownload(radarrHistoryMatch, context, {
+        ...commonOptions,
+        arrType: 'radarr',
+        progress: 100 // completed
+      });
+      if (dlObj) matched.push(dlObj);
+    }
+  }
+
+  // Deduplicate by (arrType, arrQueueId) (Issue #65)
+  const seen = new Set();
+  const deduped = [];
+  for (const m of matched) {
+    const key = (m && m.arrType && m.arrQueueId != null)
+      ? `${m.arrType}:${m.arrQueueId}`
+      : null;
+    if (key) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+    }
+    deduped.push(m);
+  }
+  return deduped;
+}
+
+/**
+ * Matches orphaned *arr queue items that have no corresponding download client item
+ * but still reside in the active Sonarr/Radarr queue.
+ * @param {Set<number>} matchedArrQueueIds - Already matched queue record IDs to skip
+ * @param {Object} context - Matching context with records, maps, and user info
+ * @returns {Array} Array of orphaned download objects
+ */
+function matchOrphanedArrRecords(matchedArrQueueIds, context) {
+  const { sonarrQueueRecords, radarrQueueRecords } = context;
+  const matched = [];
+
+  // Deduplication Strategy:
+  // We initialize the processed Set with already-matched IDs compiled during Phase 1 matching.
+  // We also track newly processed IDs locally to handle situations where multiple duplicate queue
+  // records pointing to the same downloadId exist in Sonarr/Radarr.
+  const processedQueueIds = new Set(matchedArrQueueIds);
+
+  const processRecords = (records, arrType) => {
+    for (const record of records) {
+      if (processedQueueIds.has(record.id)) continue;
+      processedQueueIds.add(record.id);
+
+      // Safe progress arithmetic to prevent NaN or division-by-zero
+      const size = record.size || 0;
+      const sizeleft = record.sizeleft || 0;
+      const progress = size > 0 ? Math.round(100 - (sizeleft / size * 100)) : 0;
+      const status = record.trackedDownloadStatus || record.status || 'Unknown';
+
+      const dl = buildArrDownload(record, context, {
+        arrType,
+        status,
+        progress,
+        client: 'orphaned',
+        instanceId: 'orphaned',
+        instanceName: 'Orphaned (unconfigured client)',
+        overrides: { isOrphaned: true }
+      });
+
+      if (dl) {
+        logger.debug(`[DownloadMatcher] Found orphaned *arr queue item: ${dl.title} (arrQueueId=${record.id})`);
+        matched.push(dl);
+      }
+    }
+  };
+
+  processRecords(sonarrQueueRecords || [], 'sonarr');
+  processRecords(radarrQueueRecords || [], 'radarr');
+
+  return matched;
+}
+
+module.exports = {
+  buildSeriesMapFromRecords,
+  buildMoviesMapFromRecords,
+  getSlotStatusAndSpeed,
+  addOmbiMatching,
+  matchSabSlots,
+  matchSabHistory,
+  matchTorrents,
+  buildArrDownload,
+  matchOrphanedArrRecords
+};

server/services/TagMatcher.js

@@ -0,0 +1,86 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const axios = require('axios');
+const cache = require('../utils/cache');
+
+// Return all resolved tag labels for a series/movie.
+// For Radarr: tags is array of IDs, tagMap is id -> label mapping.
+// For Sonarr: tags are objects with a label property.
+function extractAllTags(tags, tagMap) {
+  if (!tags || tags.length === 0) return [];
+  if (tagMap) {
+    return tags.map(id => tagMap.get(id)).filter(Boolean);
+  }
+  return tags.map(t => t && t.label).filter(Boolean);
+}
+
+// Return the tag label that matches the current username, or null.
+function extractUserTag(tags, tagMap, username) {
+  const allLabels = extractAllTags(tags, tagMap);
+  if (!allLabels.length) return null;
+  if (username) {
+    const match = allLabels.find(label => tagMatchesUser(label, username));
+    if (match) return match;
+  }
+  return null;
+}
+
+// Replicate Ombi's StringHelper.SanitizeTagLabel: lowercase, replace non-alphanumeric with hyphen, collapse, trim
+function sanitizeTagLabel(input) {
+  if (!input) return '';
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+// Check if a tag matches the username: exact match first, then sanitized match
+function tagMatchesUser(tag, username) {
+  if (!tag || !username) return false;
+  const tagLower = tag.toLowerCase();
+  // Exact match (handles users whose tags weren't mangled)
+  if (tagLower === username) return true;
+  // Sanitized match (handles Ombi-mangled tags for email-style usernames)
+  if (tagLower === sanitizeTagLabel(username)) return true;
+  return false;
+}
+
+// Fetch all Emby users and return a Map<lowerName -> displayName> (and sanitized variants).
+// Result is cached for 60s to avoid hammering Emby on every dashboard poll.
+async function getEmbyUsers() {
+  const cached = cache.get('emby:users');
+  if (cached) return cached;
+  try {
+    const response = await axios.get(`${process.env.EMBY_URL}/Users`, {
+      headers: { 'X-MediaBrowser-Token': process.env.EMBY_API_KEY }
+    });
+    // Build map: both raw lowercase and sanitized form -> display name
+    const map = new Map();
+    for (const u of response.data) {
+      const name = u.Name || '';
+      map.set(name.toLowerCase(), name);
+      map.set(sanitizeTagLabel(name), name);
+    }
+    cache.set('emby:users', map, 60000);
+    return map;
+  } catch (err) {
+    console.error('[Dashboard] Failed to fetch Emby users:', err.message);
+    return new Map();
+  }
+}
+
+// Classify each tag label: matched to a known Emby user, or unmatched.
+// Returns array of { label, matchedUser: string|null }
+function buildTagBadges(allTags, embyUserMap) {
+  return allTags.map(label => {
+    const lower = label.toLowerCase();
+    const sanitized = sanitizeTagLabel(label);
+    const displayName = embyUserMap.get(lower) || embyUserMap.get(sanitized) || null;
+    return { label, matchedUser: displayName };
+  });
+}
+
+module.exports = {
+  extractAllTags,
+  extractUserTag,
+  sanitizeTagLabel,
+  tagMatchesUser,
+  getEmbyUsers,
+  buildTagBadges
+};

server/services/WebhookStatus.js

@@ -0,0 +1,74 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const axios = require('axios');
+const { getSonarrInstances, getRadarrInstances } = require('../utils/config');
+
+/**
+ * Check if Sofarr webhook is configured in a Sonarr/Radarr instance.
+ * @param {Object} instance - The Sonarr/Radarr instance config
+ * @param {string} type - 'Sonarr' or 'Radarr'
+ * @returns {Promise<boolean>} true if webhook is configured
+ */
+async function checkWebhookConfigured(instance, type) {
+  try {
+    const response = await axios.get(`${instance.url}/api/v3/notification`, {
+      headers: { 'X-Api-Key': instance.apiKey },
+      timeout: 5000
+    });
+    const notifications = response.data || [];
+    return notifications.some(n => n.name === 'Sofarr' && n.implementation === 'Webhook');
+  } catch (err) {
+    console.log(`[WebhookStatus] Failed to check ${type} webhook config: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Aggregate webhook metrics for a service type.
+ * @param {Object} metricsMap - Map of instance URLs to their metrics
+ * @param {boolean} configured - Whether the service is configured
+ * @returns {Object|null} Aggregated metrics or null if not configured
+ */
+function aggregateMetrics(metricsMap, configured) {
+  const values = Object.values(metricsMap);
+  if (values.length === 0) {
+    // Return default metrics if configured but no events yet
+    return configured ? {
+      enabled: true,
+      eventsReceived: 0,
+      pollsSkipped: 0,
+      lastEvent: null
+    } : null;
+  }
+  return {
+    enabled: true,
+    eventsReceived: values.reduce((sum, m) => sum + (m.eventsReceived || 0), 0),
+    pollsSkipped: values.reduce((sum, m) => sum + (m.pollsSkipped || 0), 0),
+    lastEvent: values.reduce((latest, m) => {
+      return m.lastWebhookTimestamp > latest ? m.lastWebhookTimestamp : latest;
+    }, 0)
+  };
+}
+
+/**
+ * Check if Sofarr webhook is configured in an Ombi instance.
+ * @param {Object} instance - The Ombi instance config
+ * @returns {Promise<boolean>} true if webhook is configured
+ */
+async function checkOmbiWebhookConfigured(instance) {
+  try {
+    const response = await axios.get(`${instance.url}/api/v1/Settings/notifications/webhook`, {
+      headers: { 'ApiKey': instance.apiKey },
+      timeout: 5000
+    });
+    return !!(response.data && response.data.enabled);
+  } catch (err) {
+    console.log(`[WebhookStatus] Failed to check Ombi webhook config: ${err.message}`);
+    return false;
+  }
+}
+
+module.exports = {
+  checkWebhookConfigured,
+  checkOmbiWebhookConfigured,
+  aggregateMetrics
+};

server/utils/arrQueueHelpers.js

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+//
+// Shared helpers for assembling the cached *arr queue payload.
+//
+// Both the background poller (`server/utils/poller.js`) and the webhook
+// processor (`server/routes/webhook.js`) build the `poll:sonarr-queue` and
+// `poll:radarr-queue` cache entries from an array of per-instance queue
+// responses. Historically the same `flatMap` block was duplicated across all
+// four call sites (Sonarr + Radarr × poller + webhook) and had begun to drift.
+//
+// This module centralises that logic, adds defensive null-guards, and — for
+// Sonarr only — annotates season-pack records (queue entries sharing a
+// `downloadId`) with `isSeasonPack` and `episodeCount`. See Issue #61.
+//
+const { logToFile } = require('./logger');
+
+/**
+ * Build the flattened, instance-tagged `records` array for the
+ * `poll:sonarr-queue` / `poll:radarr-queue` cache entry.
+ *
+ * @param {Array<{ instance: string, data: { records?: Array<object> } }>} queues
+ *   Per-instance queue responses as returned by
+ *   `arrRetrieverRegistry.getQueuesByType()` (or the equivalent batched
+ *   retrieval in the poller).
+ * @param {Array<{ id: string, url: string, apiKey: string, name?: string }>} instances
+ *   Configured instances; used to resolve `_instanceUrl` / `_instanceKey`.
+ * @param {'series'|'movie'} mediaKey
+ *   Sonarr records embed a `series` object; Radarr records embed a `movie`
+ *   object. The embedded object is annotated with `_instanceUrl` so that
+ *   downstream link builders work.
+ * @returns {Array<object>} The flattened, annotated records array.
+ */
+function buildArrQueueCache(queues, instances, mediaKey) {
+  if (!Array.isArray(queues) || queues.length === 0) return [];
+  if (mediaKey !== 'series' && mediaKey !== 'movie') {
+    logToFile(`[arrQueueHelpers] Invalid mediaKey "${mediaKey}"; expected 'series' or 'movie'`);
+    return [];
+  }
+  const safeInstances = Array.isArray(instances) ? instances : [];
+
+  const out = [];
+  for (const q of queues) {
+    try {
+      if (!q || !q.data) continue;
+      const inst = safeInstances.find(i => i.id === q.instance);
+      const url = inst ? inst.url : null;
+      const key = inst ? inst.apiKey : null;
+      const records = Array.isArray(q.data.records) ? q.data.records : [];
+      for (const r of records) {
+        try {
+          if (!r) continue;
+          if (r[mediaKey]) {
+            r[mediaKey]._instanceUrl = url;
+          }
+          r._instanceUrl = url;
+          r._instanceKey = key;
+          out.push(r);
+        } catch (perRecordErr) {
+          logToFile(`[arrQueueHelpers] Skipping malformed ${mediaKey} record: ${perRecordErr.message}`);
+        }
+      }
+    } catch (perInstanceErr) {
+      logToFile(`[arrQueueHelpers] Skipping malformed ${mediaKey} queue payload: ${perInstanceErr.message}`);
+    }
+  }
+
+  // Sonarr-only: season pack annotation. Group by downloadId; entries that
+  // share a downloadId are episodes belonging to the same release (a season
+  // pack). Movies (mediaKey === 'movie') are single-record by nature.
+  if (mediaKey === 'series') {
+    try {
+      const groups = new Map();
+      for (const r of out) {
+        const dlId = r && r.downloadId;
+        if (!dlId) continue;
+        if (!groups.has(dlId)) groups.set(dlId, []);
+        groups.get(dlId).push(r);
+      }
+      for (const group of groups.values()) {
+        if (group.length > 1) {
+          for (const r of group) {
+            r.isSeasonPack = true;
+            r.episodeCount = group.length;
+          }
+        }
+      }
+    } catch (annotateErr) {
+      logToFile(`[arrQueueHelpers] Season-pack annotation failed: ${annotateErr.message}`);
+    }
+  }
+
+  return out;
+}
+
+module.exports = {
+  buildArrQueueCache
+};

server/utils/arrRetrievers.js

@@ -1,18 +1,24 @@
 // Copyright (c) 2026 Gordon Bolton. MIT License.
 const { logToFile } = require('./logger');
+const cache = require('./cache');
 const {
   getSonarrInstances,
-  getRadarrInstances
+  getRadarrInstances,
+  getOmbiInstances
 } = require('./config');
 
+const TagMatcher = require('../services/TagMatcher');
+
 // Import retriever classes
 const PollingSonarrRetriever = require('../clients/PollingSonarrRetriever');
 const PollingRadarrRetriever = require('../clients/PollingRadarrRetriever');
+const OmbiRetriever = require('../clients/OmbiRetriever');
 
 // Retriever type mapping
 const retrieverClasses = {
   sonarr: PollingSonarrRetriever,
-  radarr: PollingRadarrRetriever
+  radarr: PollingRadarrRetriever,
+  ombi: OmbiRetriever
 };
 
 /**
@@ -35,11 +41,13 @@ const arrRetrieverRegistry = {
     // Get all instance configurations
     const sonarrInstances = getSonarrInstances();
     const radarrInstances = getRadarrInstances();
+    const ombiInstances = getOmbiInstances();
 
     // Create retriever instances
     const instanceConfigs = [
       ...sonarrInstances.map(inst => ({ ...inst, type: 'sonarr' })),
-      ...radarrInstances.map(inst => ({ ...inst, type: 'radarr' }))
+      ...radarrInstances.map(inst => ({ ...inst, type: 'radarr' })),
+      ...ombiInstances.map(inst => ({ ...inst, type: 'ombi' }))
     ];
 
     for (const config of instanceConfigs) {
@@ -302,7 +310,151 @@ const arrRetrieverRegistry = {
         .filter(result => result.status === 'fulfilled')
         .map(result => result.value)
     };
+  },
+
+  /**
+   * Get Ombi retrievers
+   * @returns {Array<OmbiRetriever>} Array of Ombi retriever instances
+   */
+  getOmbiRetrievers() {
+    return this.getRetrieversByType('ombi');
+  },
+
+  /**
+   * Get all Ombi requests
+   * @param {boolean} force - Whether to force refresh from API
+   * @returns {Promise<Object>} Object with movie and TV request arrays
+   */
+  async getOmbiRequests(force = false) {
+    const ombiRetrievers = this.getOmbiRetrievers();
+    if (ombiRetrievers.length === 0) {
+      return { movie: [], tv: [] };
+    }
+
+    // Use the first Ombi retriever (single instance expected)
+    const retriever = ombiRetrievers[0];
+    try {
+      const movieRequests = await retriever.getMovieRequests(force);
+      const tvRequests = await retriever.getTvRequests(false);
+      return { movie: movieRequests, tv: tvRequests };
+    } catch (error) {
+      logToFile(`[ArrRetrieverRegistry] Error fetching Ombi requests: ${error.message}`);
+      return { movie: [], tv: [] };
+    }
+  },
+
+  /**
+   * Get Ombi requests grouped by type
+   * @param {boolean} force - Whether to force refresh from API
+   * @returns {Promise<Object>} Requests grouped by type (movie, tv)
+   */
+  async getOmbiRequestsByType(force = false) {
+    return await this.getOmbiRequests(force);
+  },
+
+  /**
+   * Find Ombi request by external IDs
+   * @param {string} type - 'movie' or 'tv'
+   * @param {Object} externalIds - External IDs to search with
+   * @param {string} externalIds.tmdbId - TheMovieDB ID
+   * @param {string} externalIds.tvdbId - TheTVDB ID (for TV)
+   * @param {string} externalIds.imdbId - IMDB ID (for movies)
+   * @returns {Promise<Object|null>} Ombi request object or null if not found
+   */
+  async findOmbiRequest(type, externalIds) {
+    const ombiRetrievers = this.getOmbiRetrievers();
+    if (ombiRetrievers.length === 0) {
+      return null;
+    }
+
+    const retriever = ombiRetrievers[0];
+    try {
+      if (type === 'movie') {
+        return await retriever.findMovieRequest(externalIds.tmdbId, externalIds.imdbId);
+      } else if (type === 'tv') {
+        return await retriever.findTvRequest(externalIds.tvdbId, externalIds.tmdbId);
+      }
+    } catch (error) {
+      logToFile(`[ArrRetrieverRegistry] Error finding Ombi request: ${error.message}`);
+    }
+    return null;
   }
 };
 
+
+
+/**
+ * Matching / aggregation helper function to compare a download item and an *arr item.
+ */
+function matchDownload(download, arrItem, username, tagMap) {
+  if (!download || !arrItem) return false;
+
+  // 1. First attempt an exact ID match using the stable fields that exist in the fetched data
+  if (download.arrInfo) {
+    // Sonarr stable IDs
+    if (download.arrInfo.episodeFileId !== undefined && arrItem.episodeFileId !== undefined) {
+      if (download.arrInfo.episodeFileId === arrItem.episodeFileId) return true;
+    }
+    if (download.arrInfo.episodeId !== undefined && arrItem.episodeId !== undefined) {
+      if (download.arrInfo.episodeId === arrItem.episodeId) return true;
+    }
+    if (download.arrInfo.seriesId !== undefined && arrItem.seriesId !== undefined) {
+      if (download.arrInfo.seriesId === arrItem.seriesId) return true;
+    }
+
+    // Radarr stable IDs
+    if (download.arrInfo.movieFileId !== undefined && arrItem.movieFileId !== undefined) {
+      if (download.arrInfo.movieFileId === arrItem.movieFileId) return true;
+    }
+    if (download.arrInfo.movieId !== undefined && arrItem.movieId !== undefined) {
+      if (download.arrInfo.movieId === arrItem.movieId) return true;
+    }
+  }
+
+  // 2. Only fall back to the existing title + tag string matching if no ID match is possible
+  const dlTitle = (download.title || '').toLowerCase();
+  const arrTitle = (arrItem.title || arrItem.sourceTitle || '').toLowerCase();
+  const titleMatches = dlTitle && arrTitle && (dlTitle.includes(arrTitle) || arrTitle.includes(dlTitle));
+
+  if (!titleMatches) return false;
+
+  // Preserve the existing lowercase-username tag logic exactly
+  if (!username) return true;
+
+  const getLabels = (item) => {
+    if (!item) return [];
+    const tags = item.tags || (item.series && item.series.tags) || (item.movie && item.movie.tags) || [];
+    return tags.map(t => {
+      if (typeof t === 'object' && t !== null) {
+        return t.label || t.name;
+      }
+      if (tagMap && tagMap.has && tagMap.has(t)) {
+        return tagMap.get(t);
+      }
+      
+      // Try resolving from cache as fallback
+      const cachedSonarrTags = cache.get('poll:sonarr-tags') || [];
+      const cachedRadarrTags = cache.get('poll:radarr-tags') || [];
+      const allCachedTags = [...cachedSonarrTags, ...cachedRadarrTags];
+      const found = allCachedTags.find(tag => tag && tag.id === t);
+      if (found) return found.label || found.name;
+      
+      return t;
+    }).filter(Boolean);
+  };
+
+  const dlTags = getLabels(download);
+  const arrTags = getLabels(arrItem);
+  const allTags = [...dlTags, ...arrTags];
+
+  return allTags.some(tag => TagMatcher.tagMatchesUser(tag, username.toLowerCase()));
+}
+
+// Attach matching helper functions to the registry object
+arrRetrieverRegistry.matchDownload = matchDownload;
+arrRetrieverRegistry.matchDownloadToArr = matchDownload;
+arrRetrieverRegistry.aggregateMatch = matchDownload;
+arrRetrieverRegistry.matchingHelper = matchDownload;
+arrRetrieverRegistry.compareDownloadAndArr = matchDownload;
+
 module.exports = arrRetrieverRegistry;

server/utils/config.js

@@ -84,6 +84,14 @@ function getRadarrInstances() {
   );
 }
 
+function getOmbiInstances() {
+  return parseInstances(
+    process.env.OMBI_INSTANCES,
+    process.env.OMBI_URL,
+    process.env.OMBI_API_KEY
+  );
+}
+
 function getQbittorrentInstances() {
   return parseInstances(
     process.env.QBITTORRENT_INSTANCES,
@@ -122,15 +130,21 @@ function getSofarrBaseUrl() {
   return process.env.SOFARR_BASE_URL || '';
 }
 
+function getSofarrWebhookBaseUrl() {
+  return process.env.SOFARR_WEBHOOK_BASE_URL || process.env.SOFARR_BASE_URL || '';
+}
+
 module.exports = {
   getSABnzbdInstances,
   getSonarrInstances,
   getRadarrInstances,
+  getOmbiInstances,
   getQbittorrentInstances,
   getTransmissionInstances,
   getRtorrentInstances,
   getWebhookSecret,
   getSofarrBaseUrl,
+  getSofarrWebhookBaseUrl,
   parseInstances,
   validateInstanceUrl
 };

server/utils/downloadClients.js

@@ -149,18 +149,42 @@ class DownloadClientRegistry {
     const clients = this.getAllClients();
     const result = {};
 
-    // Group by client type
+    if (clients.length === 0) {
+      return result;
+    }
+
+    // Reset fallback flags for qBittorrent clients
     for (const client of clients) {
+      if (client.resetFallbackFlag) {
+        client.resetFallbackFlag();
+      }
+    }
+
+    // Fetch downloads from all clients in parallel
+    const results = await Promise.allSettled(
+      clients.map(async (client) => {
+        const downloads = await client.getActiveDownloads();
+        return {
+          type: client.getClientType(),
+          downloads
+        };
+      })
+    );
+
+    // Group by client type
+    for (let i = 0; i < clients.length; i++) {
+      const client = clients[i];
       const type = client.getClientType();
       if (!result[type]) {
         result[type] = [];
       }
 
-      try {
-        const downloads = await client.getActiveDownloads();
-        result[type].push(...downloads);
-      } catch (error) {
-        logToFile(`[DownloadClientRegistry] Error fetching from ${client.name}: ${error.message}`);
+      const res = results[i];
+      if (res.status === 'fulfilled' && res.value) {
+        result[type].push(...res.value.downloads);
+      } else {
+        const errorMsg = res.status === 'rejected' ? res.reason?.message : 'Unknown error';
+        logToFile(`[DownloadClientRegistry] Error fetching from ${client.name}: ${errorMsg}`);
       }
     }
 
@@ -215,7 +239,10 @@ class DownloadClientRegistry {
             instanceId: client.getInstanceId(),
             instanceName: client.name,
             clientType: client.getClientType(),
-            status
+            status,
+            // Surface the per-client lastError so admins can see transient
+            // failures (auth expiry, RPC blips, etc.) without scraping logs.
+            lastError: typeof client.getLastError === 'function' ? client.getLastError() : null
           };
         } catch (error) {
           logToFile(`[DownloadClientRegistry] Error getting status from ${client.name}: ${error.message}`);
@@ -224,7 +251,8 @@ class DownloadClientRegistry {
             instanceName: client.name,
             clientType: client.getClientType(),
             status: null,
-            error: error.message
+            error: error.message,
+            lastError: typeof client.getLastError === 'function' ? client.getLastError() : null
           };
         }
       })

server/utils/historyFetcher.js

@@ -7,6 +7,20 @@ const arrRetrieverRegistry = require('./arrRetrievers');
 // History changes slowly compared to active downloads.
 const HISTORY_CACHE_TTL = 5 * 60 * 1000;
 
+// Staged loading configuration
+const INITIAL_PAGE_SIZE = 100;
+const MAX_TOTAL_RECORDS = 1000;
+const MAX_PAGES = 10; // 10 pages * 100 records = 1000 total
+
+// Background fetch state to prevent concurrent fetches
+const backgroundFetchState = {
+  sonarr: { inProgress: false, lastFetchTime: 0 },
+  radarr: { inProgress: false, lastFetchTime: 0 }
+};
+
+// Event subscribers for history updates
+const historyUpdateSubscribers = new Set();
+
 // Sonarr event types that represent a successful import
 const SONARR_IMPORTED_EVENTS = new Set(['downloadFolderImported', 'downloadImported']);
 // Sonarr event types that represent a failed import
@@ -18,13 +32,20 @@ const RADARR_FAILED_EVENTS = new Set(['downloadFailed', 'importFailed']);
 /**
  * Fetch recent history records from all Sonarr instances for the given date window.
  * Results are cached under 'history:sonarr' for HISTORY_CACHE_TTL.
+ * Uses staged loading: fetches 100 records immediately, then background-fetches up to 1000.
  * @param {Date} since - Only include records on or after this date
  * @returns {Promise<Array>} Flat array of Sonarr history records (with _instanceUrl and _instanceName)
  */
 async function fetchSonarrHistory(since) {
   const cacheKey = 'history:sonarr';
   const cached = cache.get(cacheKey);
-  if (cached) return cached;
+  if (cached) {
+    // Only trigger background refresh if cache is incomplete (less than max records)
+    if (!backgroundFetchState.sonarr.inProgress && cached.length < MAX_TOTAL_RECORDS) {
+      triggerBackgroundSonarrFetch(since);
+    }
+    return cached;
+  }
 
   // Ensure retrievers are initialized
   await arrRetrieverRegistry.initialize();
@@ -32,13 +53,15 @@ async function fetchSonarrHistory(since) {
   const instances = getSonarrInstances();
   const sonarrRetrievers = arrRetrieverRegistry.getRetrieversByType('sonarr');
 
+  // Stage 1: Fetch initial batch (100 records)
   const results = await Promise.all(sonarrRetrievers.map(async (retriever) => {
     const inst = instances.find(i => i.id === retriever.getInstanceId());
     if (!inst) return [];
 
     try {
       const response = await retriever.getHistory({
-        pageSize: 100,
+        pageSize: INITIAL_PAGE_SIZE,
+        maxPages: 1,
         sortKey: 'date',
         sortDir: 'descending',
         includeSeries: true,
@@ -61,19 +84,96 @@ async function fetchSonarrHistory(since) {
 
   const flat = results.flat();
   cache.set(cacheKey, flat, HISTORY_CACHE_TTL);
+
+  // Stage 2: Trigger background fetch for remaining records
+  triggerBackgroundSonarrFetch(since);
+
   return flat;
 }
 
+/**
+ * Trigger background fetch for remaining Sonarr history records.
+ * Uses the retriever's built-in pagination to fetch up to 1000 records.
+ */
+async function triggerBackgroundSonarrFetch(since) {
+  if (backgroundFetchState.sonarr.inProgress) return;
+  
+  // Debounce: don't fetch if we fetched within the last minute
+  const now = Date.now();
+  if (now - backgroundFetchState.sonarr.lastFetchTime < 60000) return;
+  
+  backgroundFetchState.sonarr.inProgress = true;
+  backgroundFetchState.sonarr.lastFetchTime = now;
+
+  try {
+    await arrRetrieverRegistry.initialize();
+    const instances = getSonarrInstances();
+    const sonarrRetrievers = arrRetrieverRegistry.getRetrieversByType('sonarr');
+
+    // Fetch all records up to MAX_PAGES using built-in pagination
+    const results = await Promise.all(sonarrRetrievers.map(async (retriever) => {
+      const inst = instances.find(i => i.id === retriever.getInstanceId());
+      if (!inst) return [];
+
+      try {
+        const response = await retriever.getHistory({
+          pageSize: INITIAL_PAGE_SIZE,
+          maxPages: MAX_PAGES,
+          sortKey: 'date',
+          sortDir: 'descending',
+          includeSeries: true,
+          includeEpisode: true,
+          startDate: since.toISOString()
+        });
+        const records = (response && response.records) || [];
+        return records.map(r => {
+          if (r.series) r.series._instanceUrl = inst.url;
+          if (r.series) r.series._instanceName = inst.name || inst.id;
+          r._instanceUrl = inst.url;
+          r._instanceName = inst.name || inst.id;
+          return r;
+        });
+      } catch (err) {
+        console.error(`[HistoryFetcher] Sonarr background fetch ${inst.id} error:`, err.message);
+        return [];
+      }
+    }));
+
+    const allRecords = results.flat();
+    
+    // Only update cache if we got records (don't overwrite with empty data on failure)
+    if (allRecords.length > 0) {
+      cache.set('history:sonarr', allRecords, HISTORY_CACHE_TTL);
+      
+      // Emit SSE event for history update
+      emitHistoryUpdate('sonarr');
+      
+      console.log(`[HistoryFetcher] Background fetch complete: ${allRecords.length} Sonarr records`);
+    }
+  } catch (err) {
+    console.error('[HistoryFetcher] Background Sonarr fetch error:', err.message);
+  } finally {
+    backgroundFetchState.sonarr.inProgress = false;
+  }
+}
+
 /**
  * Fetch recent history records from all Radarr instances for the given date window.
  * Results are cached under 'history:radarr' for HISTORY_CACHE_TTL.
+ * Uses staged loading: fetches 100 records immediately, then background-fetches up to 1000.
  * @param {Date} since - Only include records on or after this date
  * @returns {Promise<Array>} Flat array of Radarr history records (with _instanceUrl and _instanceName)
  */
 async function fetchRadarrHistory(since) {
   const cacheKey = 'history:radarr';
   const cached = cache.get(cacheKey);
-  if (cached) return cached;
+  if (cached) {
+    // Only trigger background refresh if cache is incomplete (less than max records)
+    if (!backgroundFetchState.radarr.inProgress && cached.length < MAX_TOTAL_RECORDS) {
+      triggerBackgroundRadarrFetch(since);
+    }
+    return cached;
+  }
 
   // Ensure retrievers are initialized
   await arrRetrieverRegistry.initialize();
@@ -81,13 +181,15 @@ async function fetchRadarrHistory(since) {
   const instances = getRadarrInstances();
   const radarrRetrievers = arrRetrieverRegistry.getRetrieversByType('radarr');
 
+  // Stage 1: Fetch initial batch (100 records)
   const results = await Promise.all(radarrRetrievers.map(async (retriever) => {
     const inst = instances.find(i => i.id === retriever.getInstanceId());
     if (!inst) return [];
 
     try {
       const response = await retriever.getHistory({
-        pageSize: 100,
+        pageSize: INITIAL_PAGE_SIZE,
+        maxPages: 1,
         sortKey: 'date',
         sortDir: 'descending',
         includeMovie: true,
@@ -109,9 +211,109 @@ async function fetchRadarrHistory(since) {
 
   const flat = results.flat();
   cache.set(cacheKey, flat, HISTORY_CACHE_TTL);
+
+  // Stage 2: Trigger background fetch for remaining records
+  triggerBackgroundRadarrFetch(since);
+
   return flat;
 }
 
+/**
+ * Trigger background fetch for remaining Radarr history records.
+ * Uses the retriever's built-in pagination to fetch up to 1000 records.
+ */
+async function triggerBackgroundRadarrFetch(since) {
+  if (backgroundFetchState.radarr.inProgress) return;
+  
+  // Debounce: don't fetch if we fetched within the last minute
+  const now = Date.now();
+  if (now - backgroundFetchState.radarr.lastFetchTime < 60000) return;
+  
+  backgroundFetchState.radarr.inProgress = true;
+  backgroundFetchState.radarr.lastFetchTime = now;
+
+  try {
+    await arrRetrieverRegistry.initialize();
+    const instances = getRadarrInstances();
+    const radarrRetrievers = arrRetrieverRegistry.getRetrieversByType('radarr');
+
+    // Fetch all records up to MAX_PAGES using built-in pagination
+    const results = await Promise.all(radarrRetrievers.map(async (retriever) => {
+      const inst = instances.find(i => i.id === retriever.getInstanceId());
+      if (!inst) return [];
+
+      try {
+        const response = await retriever.getHistory({
+          pageSize: INITIAL_PAGE_SIZE,
+          maxPages: MAX_PAGES,
+          sortKey: 'date',
+          sortDir: 'descending',
+          includeMovie: true,
+          startDate: since.toISOString()
+        });
+        const records = (response && response.records) || [];
+        return records.map(r => {
+          if (r.movie) r.movie._instanceUrl = inst.url;
+          if (r.movie) r.movie._instanceName = inst.name || inst.id;
+          r._instanceUrl = inst.url;
+          r._instanceName = inst.name || inst.id;
+          return r;
+        });
+      } catch (err) {
+        console.error(`[HistoryFetcher] Radarr background fetch ${inst.id} error:`, err.message);
+        return [];
+      }
+    }));
+
+    const allRecords = results.flat();
+    
+    // Only update cache if we got records (don't overwrite with empty data on failure)
+    if (allRecords.length > 0) {
+      cache.set('history:radarr', allRecords, HISTORY_CACHE_TTL);
+      
+      // Emit SSE event for history update
+      emitHistoryUpdate('radarr');
+      
+      console.log(`[HistoryFetcher] Background fetch complete: ${allRecords.length} Radarr records`);
+    }
+  } catch (err) {
+    console.error('[HistoryFetcher] Background Radarr fetch error:', err.message);
+  } finally {
+    backgroundFetchState.radarr.inProgress = false;
+  }
+}
+
+/**
+ * Subscribe to history update events.
+ * @param {Function} callback - Function to call when history is updated
+ */
+function onHistoryUpdate(callback) {
+  historyUpdateSubscribers.add(callback);
+}
+
+/**
+ * Unsubscribe from history update events.
+ * @param {Function} callback - Function to remove from subscribers
+ */
+function offHistoryUpdate(callback) {
+  historyUpdateSubscribers.delete(callback);
+}
+
+/**
+ * Emit SSE event for history update.
+ * Notifies all subscribers when history cache is updated.
+ */
+function emitHistoryUpdate(type) {
+  console.log(`[HistoryFetcher] History updated for ${type}, notifying ${historyUpdateSubscribers.size} subscribers`);
+  historyUpdateSubscribers.forEach(callback => {
+    try {
+      callback(type);
+    } catch (err) {
+      console.error('[HistoryFetcher] Error in history update subscriber:', err.message);
+    }
+  });
+}
+
 /**
  * Classify a Sonarr history record's event type.
  * @param {string} eventType
@@ -149,5 +351,7 @@ module.exports = {
   classifySonarrEvent,
   classifyRadarrEvent,
   invalidateHistoryCache,
+  onHistoryUpdate,
+  offHistoryUpdate,
   HISTORY_CACHE_TTL
 };

server/utils/logCapture.js

@@ -0,0 +1,131 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+const EventEmitter = require('events');
+
+class LogEmitter extends EventEmitter {}
+const logEmitter = new LogEmitter();
+
+const logBuffer = [];
+const clientLogBuffer = [];
+const MAX_BUFFER_SIZE = 1000;
+
+// ANSI escape code regular expression for stripping terminal colors
+const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+function stripAnsi(str) {
+  return typeof str === 'string' ? str.replace(ansiRegex, '') : str;
+}
+
+// Keep track of original stdout/stderr write functions
+const originalStdoutWrite = process.stdout.write;
+const originalStderrWrite = process.stderr.write;
+
+// Buffer to accumulate partial lines from stdout and stderr
+let stdoutLineBuffer = '';
+let stderrLineBuffer = '';
+
+function processStreamData(data, encoding, callback, streamName, lineAccumulator) {
+  let str = '';
+  if (Buffer.isBuffer(data)) {
+    str = data.toString(encoding || 'utf8');
+  } else if (typeof data === 'string') {
+    str = data;
+  }
+
+  // Delegate writing to the original stream first
+  callback.call(this, data, encoding);
+
+  // Append new data to the accumulator
+  const accumulated = lineAccumulator.buffer + str;
+  const lines = accumulated.split(/\r?\n/);
+
+  // The last element is either empty (if str ended with \n) or a partial line
+  lineAccumulator.buffer = lines.pop();
+
+  for (const line of lines) {
+    const cleanLine = stripAnsi(line);
+    if (!cleanLine) continue;
+
+    // Prepend timestamp if not present (format: [ISO] Message)
+    const timestampedLine = cleanLine.startsWith('[') 
+      ? cleanLine 
+      : `[${new Date().toISOString()}] [${streamName.toUpperCase()}] ${cleanLine}`;
+
+    logBuffer.push(timestampedLine);
+    if (logBuffer.length > MAX_BUFFER_SIZE) {
+      logBuffer.shift();
+    }
+
+    logEmitter.emit('server-log', timestampedLine);
+  }
+}
+
+// Accumulator objects to allow updating string buffers by reference
+const stdoutAccumulator = { buffer: '' };
+const stderrAccumulator = { buffer: '' };
+
+let isHooked = false;
+
+function init() {
+  if (isHooked) return;
+
+  // Intercept stdout
+  process.stdout.write = function(data, encoding, callback) {
+    processStreamData.call(
+      process.stdout,
+      data,
+      encoding,
+      originalStdoutWrite,
+      'stdout',
+      stdoutAccumulator
+    );
+    if (typeof callback === 'function') callback();
+    return true;
+  };
+
+  // Intercept stderr
+  process.stderr.write = function(data, encoding, callback) {
+    processStreamData.call(
+      process.stderr,
+      data,
+      encoding,
+      originalStderrWrite,
+      'stderr',
+      stderrAccumulator
+    );
+    if (typeof callback === 'function') callback();
+    return true;
+  };
+
+  isHooked = true;
+}
+
+/**
+ * Ingests a list of client-side logs into the rolling clientLogBuffer.
+ * Each client log is expected to have structure: { timestamp, level, message }
+ */
+function ingestClientLogs(logs) {
+  if (!Array.isArray(logs)) return;
+
+  for (const log of logs) {
+    const timestamp = log.timestamp || new Date().toISOString();
+    const level = (log.level || 'info').toUpperCase();
+    const msg = typeof log.message === 'string' ? log.message : JSON.stringify(log.message);
+
+    const formattedLog = `[${timestamp}] [CLIENT] [${level}] ${stripAnsi(msg)}`;
+    clientLogBuffer.push(formattedLog);
+
+    if (clientLogBuffer.length > MAX_BUFFER_SIZE) {
+      clientLogBuffer.shift();
+    }
+
+    logEmitter.emit('client-log', formattedLog);
+  }
+}
+
+module.exports = {
+  init,
+  logEmitter,
+  logBuffer,
+  clientLogBuffer,
+  ingestClientLogs
+};

server/utils/logger.js

@@ -1,16 +1,7 @@
 // Copyright (c) 2026 Gordon Bolton. MIT License.
-const fs = require('fs');
-const path = require('path');
-
-// Use DATA_DIR so the non-root container user (UID 1000) can write logs.
-// Falls back to ../../data/server.log (same directory index.js uses).
-const DATA_DIR = process.env.DATA_DIR || path.join(__dirname, '../../data');
-if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
-
-const logFile = fs.createWriteStream(path.join(DATA_DIR, 'server.log'), { flags: 'a' });
 
 function logToFile(message) {
-  logFile.write(`[${new Date().toISOString()}] ${message}\n`);
+  console.log(message);
 }
 
 module.exports = {

server/utils/ombiFilters.js

@@ -0,0 +1,137 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Pure filter / sort / search utilities for Ombi requests.
+ * Must stay in sync with client/src/utils/ombiFilters.js
+ */
+
+/**
+ * Derive a single status string from an Ombi request object.
+ * Priority: available > denied > approved > pending > unknown
+ *
+ * @param {Object} request
+ * @returns {string} 'available' | 'denied' | 'approved' | 'pending' | 'unknown'
+ */
+function getRequestStatus(request) {
+  if (!request) return 'unknown';
+  if (request.available) return 'available';
+  if (request.denied) return 'denied';
+  if (request.approved) return 'approved';
+  if (request.requested) return 'pending';
+
+  // Ombi TV requests store status flags inside childRequests
+  if (Array.isArray(request.childRequests) && request.childRequests.length > 0) {
+    for (const child of request.childRequests) {
+      if (child && child.available) return 'available';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.denied) return 'denied';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.approved) return 'approved';
+    }
+    for (const child of request.childRequests) {
+      if (child && child.requested) return 'pending';
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Filter requests by media type.
+ *
+ * @param {Array} requests
+ * @param {string[]} types - e.g. ['movie', 'tv'] or ['all']
+ * @returns {Array}
+ */
+function filterByType(requests, types) {
+  if (!types || types.length === 0) return requests;
+  const normalized = types.map(t => t.toLowerCase());
+  if (normalized.includes('all')) return requests;
+  return requests.filter(r => normalized.includes(r.mediaType));
+}
+
+/**
+ * Filter requests by status.
+ *
+ * @param {Array} requests
+ * @param {string[]} statuses - e.g. ['pending', 'approved', 'available', 'denied']
+ * @returns {Array}
+ */
+function filterByStatus(requests, statuses) {
+  if (!statuses || statuses.length === 0) return requests;
+  const normalized = statuses.map(s => s.toLowerCase());
+  return requests.filter(r => normalized.includes(getRequestStatus(r)));
+}
+
+/**
+ * Filter requests by case-insensitive title substring.
+ *
+ * @param {Array} requests
+ * @param {string} query
+ * @returns {Array}
+ */
+function filterBySearch(requests, query) {
+  if (!query || query.trim() === '') return requests;
+  const q = query.trim().toLowerCase();
+  return requests.filter(r => (r.title || '').toLowerCase().includes(q));
+}
+
+/**
+ * Sort requests by the given sort mode.
+ *
+ * @param {Array} requests
+ * @param {string} sortMode - requestedDate_desc | requestedDate_asc | title_asc | title_desc
+ * @returns {Array} new sorted array
+ */
+function sortRequests(requests, sortMode) {
+  const sorted = [...requests];
+  switch (sortMode) {
+    case 'requestedDate_asc':
+      return sorted.sort((a, b) => {
+        const da = a.requestedDate ? new Date(a.requestedDate).getTime() : 0;
+        const db = b.requestedDate ? new Date(b.requestedDate).getTime() : 0;
+        return da - db;
+      });
+    case 'title_asc':
+      return sorted.sort((a, b) => (a.title || '').localeCompare(b.title || ''));
+    case 'title_desc':
+      return sorted.sort((a, b) => (b.title || '').localeCompare(a.title || ''));
+    case 'requestedDate_desc':
+    default:
+      return sorted.sort((a, b) => {
+        const da = a.requestedDate ? new Date(a.requestedDate).getTime() : 0;
+        const db = b.requestedDate ? new Date(b.requestedDate).getTime() : 0;
+        return db - da;
+      });
+  }
+}
+
+/**
+ * Apply all filters and sorting in one call.
+ *
+ * @param {Array} requests
+ * @param {Object} options
+ * @param {string[]} options.types
+ * @param {string[]} options.statuses
+ * @param {string} options.sort
+ * @param {string} options.search
+ * @returns {Array}
+ */
+function applyRequestFilters(requests, { types, statuses, sort, search } = {}) {
+  let result = [...requests];
+  result = filterByType(result, types);
+  result = filterByStatus(result, statuses);
+  result = filterBySearch(result, search);
+  result = sortRequests(result, sort);
+  return result;
+}
+
+module.exports = {
+  getRequestStatus,
+  filterByType,
+  filterByStatus,
+  filterBySearch,
+  sortRequests,
+  applyRequestFilters
+};

server/utils/ombiHelpers.js

@@ -0,0 +1,239 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * Helper functions for extracting user information from Ombi API responses.
+ * The Ombi API returns requestedUser as an OmbiStore.Entities.OmbiUser object,
+ * not a string, so we need to extract the username from the object.
+ */
+
+const { logToFile } = require('./logger');
+
+/**
+ * Extracts the username from an Ombi request object.
+ * Handles both the OmbiUser object format and legacy string format.
+ * 
+ * @param {Object} request - The Ombi request object
+ * @returns {string} The extracted username, or empty string if not found
+ */
+function extractRequestedUser(request) {
+  if (!request) return '';
+  
+  // Try to locate a user object or string from various fields common to Ombi Movies and TV shows
+  const userSource = request.requestedUser || request.RequestedUser ||
+                     request.user || request.User ||
+                     request.requestedBy || request.RequestedBy ||
+                     request.ombiUser || request.OmbiUser ||
+                     request.requestedByUser || request.RequestedByUser;
+
+  // If userSource is an object, extract key fields
+  if (userSource && typeof userSource === 'object') {
+    const username = userSource.alias || userSource.Alias ||
+                     userSource.userAlias || userSource.UserAlias ||
+                     userSource.userName || userSource.UserName ||
+                     userSource.normalizedUserName || userSource.NormalizedUserName ||
+                     userSource.displayName || userSource.DisplayName ||
+                     userSource.email || userSource.Email;
+    if (username) return username;
+  }
+
+  // If userSource is a string and not an empty object/array
+  if (userSource && typeof userSource === 'string') {
+    return userSource;
+  }
+
+  // Fallbacks on the request root level
+  const rootFallback = request.requestedByAlias || request.RequestedByAlias ||
+                       request.requestedByUsername || request.RequestedByUsername ||
+                       request.requester || request.Requester ||
+                       request.requestedByEmail || request.RequestedByEmail;
+  if (rootFallback) return rootFallback;
+
+  // Check seasons / childRequests nested arrays (common for Ombi TV show requests)
+  if (Array.isArray(request.seasons)) {
+    for (const season of request.seasons) {
+      const seasonUser = extractRequestedUser(season);
+      if (seasonUser) return seasonUser;
+    }
+  }
+  
+  if (Array.isArray(request.childRequests)) {
+    for (const child of request.childRequests) {
+      const childUser = extractRequestedUser(child);
+      if (childUser) return childUser;
+    }
+  }
+
+  // Add warning log when user extraction returns empty for non-empty requests
+  if (Object.keys(request).length > 0 && !request.notificationType) {
+    logToFile(`[Ombi] WARNING: User extraction failed for request: ${JSON.stringify(request)}`);
+  }
+
+  return '';
+}
+
+function filterRequestsByUser(requests, username, showAll) {
+  if (!Array.isArray(requests)) return [];
+  if (showAll || !username) return requests;
+  const usernameLower = username.toLowerCase();
+  return requests.filter(req => {
+    const requestedUser = extractRequestedUser(req);
+    return requestedUser.toLowerCase() === usernameLower;
+  });
+}
+
+async function decorateRequestsWithArrLinks(requests, isAdmin) {
+  if (!isAdmin || !Array.isArray(requests)) return;
+
+  const arrRetrieverRegistry = require('./arrRetrievers');
+  await arrRetrieverRegistry.initialize();
+
+  const sonarrRetrievers = arrRetrieverRegistry.getRetrieversByType('sonarr') || [];
+  const radarrRetrievers = arrRetrieverRegistry.getRetrieversByType('radarr') || [];
+
+  const [sonarrData, radarrData] = await Promise.all([
+    Promise.all(sonarrRetrievers.map(async r => {
+      try {
+        const response = await require('axios').get(`${r.url}/api/v3/series`, {
+          headers: { 'X-Api-Key': r.apiKey }
+        });
+        return { instance: r, series: response.data || [] };
+      } catch {
+        return { instance: r, series: [] };
+      }
+    })),
+    Promise.all(radarrRetrievers.map(async r => {
+      try {
+        const response = await require('axios').get(`${r.url}/api/v3/movie`, {
+          headers: { 'X-Api-Key': r.apiKey }
+        });
+        return { instance: r, movies: response.data || [] };
+      } catch {
+        return { instance: r, movies: [] };
+      }
+    }))
+  ]);
+
+  requests.forEach(req => {
+    // Determine if it's TV or Movie. Often `mediaType` is set, or `type === 'Tv'`
+    // Fallback to checking for TV specific IDs.
+    const isTv = req.mediaType === 'tv' || req.type === 'Tv' || req.tvDbId || req.tvdbId || req.theTvDbId || req.theTvdbId || req.TvDbId || req.TheTvDbId;
+
+    if (isTv) {
+      const tvdbId = req.theTvDbId || req.theTvdbId || req.tvDbId || req.tvdbId || req.TvDbId || req.TheTvDbId || req.theMovieDbId || req.theTmdbId;
+      if (!tvdbId) return;
+
+      for (const instData of sonarrData) {
+        const match = instData.series.find(s => s && (s.tvdbId === parseInt(tvdbId, 10) || s.tmdbId === parseInt(tvdbId, 10)));
+        if (match && match.titleSlug) {
+          req.arrLink = `${instData.instance.url}/series/${match.titleSlug}`;
+          req.arrType = 'sonarr';
+          break;
+        }
+      }
+    } else {
+      const tmdbId = req.theMovieDbId || req.imdbId || req.theTmdbId || req.TheMovieDbId || req.ImdbId;
+      if (!tmdbId) return;
+
+      for (const instData of radarrData) {
+        const match = instData.movies.find(m => m && (m.tmdbId === parseInt(tmdbId, 10) || m.imdbId === tmdbId));
+        if (match && match.titleSlug) {
+          req.arrLink = `${instData.instance.url}/movie/${match.titleSlug}`;
+          req.arrType = 'radarr';
+          break;
+        }
+      }
+    }
+  });
+}
+
+async function decorateDownloadsWithArrLinks(downloads, isAdmin) {
+  if (!isAdmin || !Array.isArray(downloads)) return;
+
+  const arrRetrieverRegistry = require('./arrRetrievers');
+  await arrRetrieverRegistry.initialize();
+
+  const sonarrRetrievers = arrRetrieverRegistry.getRetrieversByType('sonarr') || [];
+  const radarrRetrievers = arrRetrieverRegistry.getRetrieversByType('radarr') || [];
+
+  const [sonarrData, radarrData] = await Promise.all([
+    Promise.all(sonarrRetrievers.map(async r => {
+      try {
+        const response = await require('axios').get(`${r.url}/api/v3/series`, {
+          headers: { 'X-Api-Key': r.apiKey }
+        });
+        return { instance: r, series: response.data || [] };
+      } catch {
+        return { instance: r, series: [] };
+      }
+    })),
+    Promise.all(radarrRetrievers.map(async r => {
+      try {
+        const response = await require('axios').get(`${r.url}/api/v3/movie`, {
+          headers: { 'X-Api-Key': r.apiKey }
+        });
+        return { instance: r, movies: response.data || [] };
+      } catch {
+        return { instance: r, movies: [] };
+      }
+    }))
+  ]);
+
+  downloads.forEach(dl => {
+    // Determine if it's TV (series) or Movie
+    const isTv = dl.type === 'series' || dl.arrType === 'sonarr';
+
+    if (isTv) {
+      // Look for a match in Sonarr instances
+      for (const instData of sonarrData) {
+        const match = instData.series.find(s => {
+          if (!s) return false;
+          // Match by database series ID if the instance matches
+          const instanceUrlMatch = dl.arrInstanceUrl === instData.instance.url;
+          if (instanceUrlMatch && dl.arrSeriesId != null && s.id === parseInt(dl.arrSeriesId, 10)) {
+            return true;
+          }
+          // Fallback to seriesName matching
+          if (dl.seriesName && s.title && dl.seriesName.toLowerCase() === s.title.toLowerCase()) {
+            return true;
+          }
+          return false;
+        });
+
+        if (match && match.titleSlug) {
+          dl.arrLink = `${instData.instance.url}/series/${match.titleSlug}`;
+          dl.arrType = 'sonarr';
+          break;
+        }
+      }
+    } else if (dl.type === 'movie' || dl.arrType === 'radarr') {
+      // Look for a match in Radarr instances
+      for (const instData of radarrData) {
+        const match = instData.movies.find(m => {
+          if (!m) return false;
+          // Match by database movie ID if instance matches
+          const instanceUrlMatch = dl.arrInstanceUrl === instData.instance.url;
+          if (instanceUrlMatch && dl.arrContentId != null && m.id === parseInt(dl.arrContentId, 10)) {
+            return true;
+          }
+          // Fallback to movieName matching
+          if (dl.movieName && m.title && dl.movieName.toLowerCase() === m.title.toLowerCase()) {
+            return true;
+          }
+          return false;
+        });
+
+        if (match && match.titleSlug) {
+          dl.arrLink = `${instData.instance.url}/movie/${match.titleSlug}`;
+          dl.arrType = 'radarr';
+          break;
+        }
+      }
+    }
+  });
+}
+
+module.exports = {
+  extractRequestedUser,
+  filterRequestsByUser,
+  decorateRequestsWithArrLinks,
+  decorateDownloadsWithArrLinks
+};

server/utils/poller.js

@@ -3,10 +3,13 @@ const axios = require('axios');
 const cache = require('./cache');
 const { initializeClients, getAllDownloads, getDownloadsByClientType } = require('./downloadClients');
 const arrRetrieverRegistry = require('./arrRetrievers');
+const { buildArrQueueCache } = require('./arrQueueHelpers');
 const {
   getSonarrInstances,
-  getRadarrInstances
+  getRadarrInstances,
+  getOmbiInstances
 } = require('./config');
+const { logToFile } = require('./logger');
 
 const rawPollInterval = (process.env.POLL_INTERVAL || '').toLowerCase();
 const POLL_INTERVAL = (rawPollInterval === 'off' || rawPollInterval === 'false' || rawPollInterval === 'disabled')
@@ -88,13 +91,14 @@ async function pollAllServices() {
 
     const sonarrInstances = getSonarrInstances();
     const radarrInstances = getRadarrInstances();
+    const ombiInstances = getOmbiInstances();
 
     // Check webhook fallback: if no webhook events for WEBHOOK_FALLBACK_TIMEOUT, force full poll
     const globalMetrics = cache.getGlobalWebhookMetrics();
     const now = Date.now();
     const lastWebhookTime = globalMetrics.lastGlobalWebhookTimestamp;
     const fallbackTriggered = lastWebhookTime && (now - lastWebhookTime) > WEBHOOK_FALLBACK_TIMEOUT_MS;
-    
+
     if (fallbackTriggered) {
       console.log(`[Poller] Webhook fallback triggered: no webhook events for ${WEBHOOK_FALLBACK_TIMEOUT_MINUTES} minutes, forcing full poll`);
     }
@@ -102,6 +106,7 @@ async function pollAllServices() {
     // Determine which instances should be polled based on webhook activity
     const shouldPollSonarr = fallbackTriggered || !shouldSkipInstancePolling(sonarrInstances, 'sonarr');
     const shouldPollRadarr = fallbackTriggered || !shouldSkipInstancePolling(radarrInstances, 'radarr');
+    const shouldPollOmbi = fallbackTriggered || !shouldSkipInstancePolling(ombiInstances, 'ombi');
 
     // All fetches in parallel, each individually timed
     const results = await Promise.all([
@@ -118,7 +123,7 @@ async function pollAllServices() {
         return queuesByType.sonarr || [];
       }) : timed('Sonarr Queue', async () => []),
       shouldPollSonarr ? timed('Sonarr History', async () => {
-        const historyByType = await arrRetrieverRegistry.getHistoryByType({ pageSize: 10 });
+        const historyByType = await arrRetrieverRegistry.getHistoryByType({ pageSize: 50 });
         return historyByType.sonarr || [];
       }) : timed('Sonarr History', async () => []),
       shouldPollRadarr ? timed('Radarr Queue', async () => {
@@ -126,13 +131,17 @@ async function pollAllServices() {
         return queuesByType.radarr || [];
       }) : timed('Radarr Queue', async () => []),
       shouldPollRadarr ? timed('Radarr History', async () => {
-        const historyByType = await arrRetrieverRegistry.getHistoryByType({ pageSize: 10 });
+        const historyByType = await arrRetrieverRegistry.getHistoryByType({ pageSize: 50 });
         return historyByType.radarr || [];
       }) : timed('Radarr History', async () => []),
       shouldPollRadarr ? timed('Radarr Tags', async () => {
         const tagsByType = await arrRetrieverRegistry.getTagsByType();
         return tagsByType.radarr || [];
       }) : timed('Radarr Tags', async () => []),
+      shouldPollOmbi ? timed('Ombi Requests', async () => {
+        const ombiRequests = await arrRetrieverRegistry.getOmbiRequests();
+        return ombiRequests;
+      }) : timed('Ombi Requests', async () => ({ movie: [], tv: [] })),
     ]);
 
     const [
@@ -140,7 +149,8 @@ async function pollAllServices() {
       { result: sonarrTagsResults }, { result: sonarrQueues },
       { result: sonarrHistories },
       { result: radarrQueues }, { result: radarrHistories },
-      { result: radarrTagsResults }
+      { result: radarrTagsResults },
+      { result: ombiRequests }
     ] = results;
 
     // Store per-task timings
@@ -178,10 +188,12 @@ async function pollAllServices() {
         cat: d.category,
         labels: d.tags.join(','),
         added: d.addedOn ? Math.floor(new Date(d.addedOn).getTime() / 1000) : null,
-        raw: d.raw
+        raw: d.raw,
+        instanceId: d.instanceId,
+        instanceName: d.instanceName
       }))
     };
-    
+
     const sabHistoryLegacy = {
       slots: sabHistory.map(d => ({
         nzo_id: d.id,
@@ -191,7 +203,9 @@ async function pollAllServices() {
         cat: d.category,
         labels: d.tags.join(','),
         added: d.addedOn ? Math.floor(new Date(d.addedOn).getTime() / 1000) : null,
-        raw: d.raw
+        raw: d.raw,
+        instanceId: d.instanceId,
+        instanceName: d.instanceName
       }))
     };
     
@@ -224,17 +238,7 @@ async function pollAllServices() {
       cache.set('poll:sonarr-tags', sonarrTagsResults, cacheTTL);
       // Tag queue/history records with _instanceUrl so embedded series/movie objects can build links
       cache.set('poll:sonarr-queue', {
-        records: sonarrQueues.flatMap(q => {
-          const inst = sonarrInstances.find(i => i.id === q.instance);
-          const url = inst ? inst.url : null;
-          const key = inst ? inst.apiKey : null;
-          return (q.data.records || []).map(r => {
-            if (r.series) r.series._instanceUrl = url;
-            r._instanceUrl = url;
-            r._instanceKey = key;
-            return r;
-          });
-        })
+        records: buildArrQueueCache(sonarrQueues, sonarrInstances, 'series')
       }, cacheTTL);
       cache.set('poll:sonarr-history', {
         records: sonarrHistories.flatMap(h => h.data.records || [])
@@ -252,17 +256,7 @@ async function pollAllServices() {
     // Radarr
     if (shouldPollRadarr) {
       cache.set('poll:radarr-queue', {
-        records: radarrQueues.flatMap(q => {
-          const inst = radarrInstances.find(i => i.id === q.instance);
-          const url = inst ? inst.url : null;
-          const key = inst ? inst.apiKey : null;
-          return (q.data.records || []).map(r => {
-            if (r.movie) r.movie._instanceUrl = url;
-            r._instanceUrl = url;
-            r._instanceKey = key;
-            return r;
-          });
-        })
+        records: buildArrQueueCache(radarrQueues, radarrInstances, 'movie')
       }, cacheTTL);
       cache.set('poll:radarr-history', {
         records: radarrHistories.flatMap(h => h.data.records || [])
@@ -278,6 +272,16 @@ async function pollAllServices() {
       if (existingRadarrTags) cache.set('poll:radarr-tags', existingRadarrTags, cacheTTL);
     }
 
+    // Ombi
+    if (shouldPollOmbi) {
+      cache.set('poll:ombi-requests', ombiRequests, cacheTTL);
+      logToFile(`[Poller] Ombi requests cached: ${ombiRequests.movie?.length || 0} movies, ${ombiRequests.tv?.length || 0} TV shows`);
+    } else {
+      // Extend TTL of existing cached data when polling is skipped
+      const existingOmbiRequests = cache.get('poll:ombi-requests');
+      if (existingOmbiRequests) cache.set('poll:ombi-requests', existingOmbiRequests, cacheTTL);
+    }
+
     // qBittorrent (already set above in download clients section)
 
     const elapsed = Date.now() - start;

server/utils/qbittorrent.js

@@ -102,6 +102,8 @@ function mapTorrentToDownload(torrent) {
   return {
     type: 'torrent',
     title: torrent.name,
+    client: 'qbittorrent',
+    instanceId: torrent.instanceId,
     instanceName: torrent.instanceName,
     status: status,
     progress: progress.toFixed(1),

tests/README.md

@@ -38,13 +38,24 @@ tests/
 │   ├── requireAuth.test.js    # Auth middleware: valid/invalid/tampered cookies
 │   ├── verifyCsrf.test.js     # CSRF double-submit cookie pattern + timing-safe compare
 │   ├── qbittorrent.test.js    # Pure utils: formatBytes, formatEta, mapTorrentToDownload
-│   └── tokenStore.test.js     # JSON file token store: store/get/clear, TTL expiry
+│   ├── tokenStore.test.js     # JSON file token store: store/get/clear, TTL expiry
+│   └── dashboard.test.js      # Pure helper functions: getCoverArt, extractAllTags,
+│                              #   extractUserTag, sanitizeTagLabel, tagMatchesUser,
+│                              #   getImportIssues, getSonarrLink, getRadarrLink,
+│                              #   canBlocklist, extractEpisode, gatherEpisodes, buildTagBadges
 └── integration/
     ├── health.test.js         # GET /health and /ready endpoints
     ├── auth.test.js           # Full login/logout/me/csrf flows via supertest + nock
     ├── history.test.js        # GET /api/history/recent: auth, filtering, deduplication
-    └── webhook.test.js        # POST /api/webhook/sonarr+radarr: secret, validation,
-                               #   replay protection, metrics, security assertions
+    ├── webhook.test.js        # POST /api/webhook/sonarr+radarr: secret, validation,
+    │                          #   replay protection, metrics, security assertions
+    ├── dashboard.test.js      # GET /user-downloads (SAB+Sonarr, SAB+Radarr, qBit, showAll,
+    │                          #   paused queue, history, importIssues), GET /status,
+    │                          #   GET /webhook-metrics, GET /cover-art, POST /blocklist-search
+    ├── emby.test.js           # GET /sessions, /users, /users/:id, /session/:id/user
+    └── arrRoutes.test.js      # Sonarr + Radarr: queue, history, series/movies, notifications
+                               #   CRUD, /test, /schema, /sofarr-webhook (create + update)
+                               # SABnzbd: queue, history
 ```
 
 ## Key design decisions
@@ -57,15 +68,30 @@ tests/
 
 ## Coverage targets
 
-The tested files meet these per-file minimums (enforced in CI):
+Global thresholds (enforced in CI via `vitest.config.js`):
 
-| File | Lines | Branches |
-|---|---|---|
-| `server/app.js` | 85% | 65% |
-| `server/routes/auth.js` | 85% | 70% |
-| `server/routes/webhook.js` | 80% | 70% |
-| `server/middleware/requireAuth.js` | 75% | 80% |
-| `server/utils/sanitizeError.js` | 60% | — |
-| `server/utils/config.js` | 50% | 55% |
+| Metric | Threshold |
+|---|---|
+| Statements | 55% |
+| Functions | 55% |
+| Branches | 40% |
+| Lines | 55% |
 
-`dashboard.js` and `poller.js` are large files requiring complex external-service mocks (Sonarr, Radarr, qBittorrent, Emby) and are tracked as future test coverage work.
+Notable per-file coverage after the current suite:
+
+| File | Lines | Branches | Notes |
+|---|---|---|---|
+| `server/app.js` | ~92% | ~71% | |
+| `server/routes/auth.js` | ~88% | ~78% | |
+| `server/routes/dashboard.js` | ~42% | ~25% | SSE `/stream` endpoint intentionally untested |
+| `server/routes/emby.js` | 100% | 100% | |
+| `server/routes/radarr.js` | ~87% | ~77% | |
+| `server/routes/sonarr.js` | ~89% | ~82% | |
+| `server/routes/sabnzbd.js` | 100% | 100% | |
+| `server/routes/webhook.js` | ~85% | ~79% | |
+| `server/middleware/requireAuth.js` | ~92% | ~81% | |
+| `server/middleware/verifyCsrf.js` | 100% | 80% | |
+| `server/utils/sanitizeError.js` | 100% | 75% | |
+| `server/utils/config.js` | ~70% | ~58% | |
+
+`poller.js` (background polling engine) and the SSE `/stream` endpoint in `dashboard.js` require time-based behaviour and long-lived HTTP connections; they remain tracked as future test coverage work.

tests/frontend/state.test.js

@@ -0,0 +1,320 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * @vitest-environment jsdom
+ * Tests for client/src/state.js
+ *
+ * Verifies the structure and initial values of the state object.
+ * This ensures the Ombi-related state fields are properly defined.
+ */
+
+import { state } from '../../client/src/state.js';
+
+describe('state object', () => {
+  it('has ombiBaseUrl field initialized to null', () => {
+    expect(state).toHaveProperty('ombiBaseUrl');
+    expect(state.ombiBaseUrl).toBeNull();
+  });
+
+  it('has ombiRequests field initialized to null', () => {
+    expect(state).toHaveProperty('ombiRequests');
+    expect(state.ombiRequests).toBeNull();
+  });
+
+  it('has ombiWebhook field with correct structure', () => {
+    expect(state).toHaveProperty('ombiWebhook');
+    expect(state.ombiWebhook).toEqual({
+      enabled: false,
+      triggers: {
+        requestAvailable: false,
+        requestApproved: false,
+        requestDeclined: false,
+        requestPending: false,
+        requestProcessing: false
+      },
+      stats: null
+    });
+  });
+
+  it('has ombiWebhook triggers with all required fields', () => {
+    const { triggers } = state.ombiWebhook;
+    expect(triggers).toHaveProperty('requestAvailable');
+    expect(triggers).toHaveProperty('requestApproved');
+    expect(triggers).toHaveProperty('requestDeclined');
+    expect(triggers).toHaveProperty('requestPending');
+    expect(triggers).toHaveProperty('requestProcessing');
+  });
+
+  it('has all Ombi trigger fields initialized to false', () => {
+    const { triggers } = state.ombiWebhook;
+    expect(triggers.requestAvailable).toBe(false);
+    expect(triggers.requestApproved).toBe(false);
+    expect(triggers.requestDeclined).toBe(false);
+    expect(triggers.requestPending).toBe(false);
+    expect(triggers.requestProcessing).toBe(false);
+  });
+
+  it('has ombiWebhook stats initialized to null', () => {
+    expect(state.ombiWebhook.stats).toBeNull();
+  });
+
+  it('has ombiWebhook enabled initialized to false', () => {
+    expect(state.ombiWebhook.enabled).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Enabled tests with robust mocking
+// ---------------------------------------------------------------------------
+
+import { enableOmbiWebhook as apiEnableOmbiWebhook, testOmbiWebhook as apiTestOmbiWebhook } from '../../client/src/api.js';
+import { renderWebhookStatus, enableOmbiWebhook as uiEnableOmbiWebhook, testOmbiWebhook as uiTestOmbiWebhook } from '../../client/src/ui/webhooks.js';
+
+const mockFetch = vi.fn().mockImplementation((url, init) => {
+  if (url === '/api/ombi/webhook/enable') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({ success: true })
+    });
+  }
+  if (url === '/api/ombi/webhook/test') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({ success: true })
+    });
+  }
+  if (url === '/api/webhook/config') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({ valid: true })
+    });
+  }
+  if (url === '/api/sonarr/notifications') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve([])
+    });
+  }
+  if (url === '/api/radarr/notifications') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve([])
+    });
+  }
+  if (url === '/api/ombi/webhook/status') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({
+        enabled: true,
+        triggers: {
+          requestAvailable: true,
+          requestApproved: true,
+          requestDeclined: true,
+          requestPending: true,
+          requestProcessing: true
+        },
+        stats: {
+          eventsReceived: 10,
+          pollsSkipped: 5,
+          lastWebhookTimestamp: Date.now() - 60000
+        }
+      })
+    });
+  }
+  if (url === '/api/webhook/metrics') {
+    return Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({})
+    });
+  }
+  return Promise.resolve({
+    ok: false,
+    status: 404
+  });
+});
+
+function setupDomForOmbiWebhooks() {
+  document.body.innerHTML = `
+    <div id="webhooks-section"></div>
+    <div id="webhooks-content"></div>
+    <div id="webhooks-toggle"></div>
+    <div id="webhook-loading" class="hidden"></div>
+    <div id="sonarr-status"></div>
+    <button id="enable-sonarr-webhook"></button>
+    <button id="test-sonarr-webhook"></button>
+    <div id="sonarr-triggers"></div>
+    <div id="sonarr-stats"></div>
+    <div id="radarr-status"></div>
+    <button id="enable-radarr-webhook"></button>
+    <button id="test-radarr-webhook"></button>
+    <div id="radarr-triggers"></div>
+    <div id="radarr-stats"></div>
+    <div id="ombi-status"></div>
+    <button id="enable-ombi-webhook"></button>
+    <button id="test-ombi-webhook"></button>
+    <div id="ombi-triggers" class="hidden">
+      <div id="ombi-requestAvailable"></div>
+      <div id="ombi-requestApproved"></div>
+      <div id="ombi-requestDeclined"></div>
+      <div id="ombi-requestPending"></div>
+      <div id="ombi-requestProcessing"></div>
+    </div>
+    <div id="ombi-stats" class="hidden">
+      <div id="ombi-events"></div>
+      <div id="ombi-polls"></div>
+      <div id="ombi-last"></div>
+    </div>
+  `;
+}
+
+describe('frontend API functions (enableOmbiWebhook, testOmbiWebhook)', () => {
+  beforeEach(() => {
+    global.fetch = mockFetch;
+    mockFetch.mockClear();
+    state.csrfToken = 'test-csrf-token';
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  it('enableOmbiWebhook makes POST request to /api/ombi/webhook/enable', async () => {
+    const result = await apiEnableOmbiWebhook();
+    expect(mockFetch).toHaveBeenCalledWith('/api/ombi/webhook/enable', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': 'test-csrf-token' }
+    });
+    expect(result).toEqual({ success: true });
+  });
+
+  it('testOmbiWebhook makes POST request to /api/ombi/webhook/test', async () => {
+    const result = await apiTestOmbiWebhook();
+    expect(mockFetch).toHaveBeenCalledWith('/api/ombi/webhook/test', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': 'test-csrf-token' }
+    });
+    expect(result).toEqual({ success: true });
+  });
+});
+
+describe('frontend UI functions (webhooks.js Ombi functions)', () => {
+  beforeEach(() => {
+    global.fetch = mockFetch;
+    mockFetch.mockClear();
+    global.alert = vi.fn();
+    setupDomForOmbiWebhooks();
+    state.csrfToken = 'test-csrf-token';
+    
+    // Set up default state for Ombi webhook
+    state.ombiWebhook = {
+      enabled: false,
+      triggers: {
+        requestAvailable: false,
+        requestApproved: false,
+        requestDeclined: false,
+        requestPending: false,
+        requestProcessing: false
+      },
+      stats: null
+    };
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+    delete global.alert;
+    document.body.innerHTML = '';
+  });
+
+  it('renderWebhookStatus renders Ombi webhook status correctly', () => {
+    // 1. Test disabled state
+    state.ombiWebhook.enabled = false;
+    renderWebhookStatus();
+    expect(document.getElementById('ombi-status').textContent).toBe('○ Disabled');
+    expect(document.getElementById('enable-ombi-webhook').classList.contains('hidden')).toBe(false);
+    expect(document.getElementById('test-ombi-webhook').classList.contains('hidden')).toBe(true);
+    expect(document.getElementById('ombi-triggers').classList.contains('hidden')).toBe(true);
+
+    // 2. Test enabled state with triggers and stats
+    state.ombiWebhook.enabled = true;
+    state.ombiWebhook.triggers.requestAvailable = true;
+    state.ombiWebhook.triggers.requestApproved = true;
+    state.ombiWebhook.stats = {
+      eventsReceived: 42,
+      pollsSkipped: 17,
+      lastWebhookTimestamp: Date.now() - 3600000 // 1 hour ago
+    };
+    renderWebhookStatus();
+    expect(document.getElementById('ombi-status').textContent).toBe('● Enabled');
+    expect(document.getElementById('enable-ombi-webhook').classList.contains('hidden')).toBe(true);
+    expect(document.getElementById('test-ombi-webhook').classList.contains('hidden')).toBe(false);
+    expect(document.getElementById('ombi-triggers').classList.contains('hidden')).toBe(false);
+    
+    // Check triggers rendering
+    expect(document.getElementById('ombi-requestAvailable').textContent).toBe('✓');
+    expect(document.getElementById('ombi-requestApproved').textContent).toBe('✓');
+    expect(document.getElementById('ombi-requestDeclined').textContent).toBe('✗');
+    
+    // Check stats rendering
+    expect(document.getElementById('ombi-stats').classList.contains('hidden')).toBe(false);
+    expect(document.getElementById('ombi-events').textContent).toBe('42');
+    expect(document.getElementById('ombi-polls').textContent).toBe('17');
+    expect(document.getElementById('ombi-last').textContent).toBe('1h ago');
+  });
+
+  it('enableOmbiWebhook UI handler calls API and updates state', async () => {
+    // Mock the state returned by fetchWebhookStatus to enable it
+    mockFetch.mockImplementation((url) => {
+      if (url === '/api/ombi/webhook/enable') {
+        return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+      }
+      if (url === '/api/ombi/webhook/status') {
+        // Return updated state where it is enabled
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({
+            enabled: true,
+            triggers: {
+              requestAvailable: true,
+              requestApproved: false,
+              requestDeclined: false,
+              requestPending: false,
+              requestProcessing: false
+            },
+            stats: null
+          })
+        });
+      }
+      // For all other config fetches, return basic values
+      return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+    });
+
+    await uiEnableOmbiWebhook();
+    
+    // Should make POST call to enable
+    expect(mockFetch).toHaveBeenCalledWith('/api/ombi/webhook/enable', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': 'test-csrf-token' }
+    });
+    
+    // State should be updated
+    expect(state.ombiWebhook.enabled).toBe(true);
+    
+    // Render the webhook status to update the DOM
+    renderWebhookStatus();
+    
+    // UI should show enabled status
+    expect(document.getElementById('ombi-status').textContent).toBe('● Enabled');
+  });
+
+  it('testOmbiWebhook UI handler calls API and updates state', async () => {
+    await uiTestOmbiWebhook();
+    
+    // Should make POST call to test
+    expect(mockFetch).toHaveBeenCalledWith('/api/ombi/webhook/test', {
+      method: 'POST',
+      headers: { 'X-CSRF-Token': 'test-csrf-token' }
+    });
+    
+    // Should alert success
+    expect(global.alert).toHaveBeenCalledWith('Ombi webhook test sent successfully!');
+  });
+});

tests/frontend/ui/downloads.test.js

@@ -0,0 +1,236 @@
+// Copyright (c) 2026 Gordon Bolton. MIT License.
+/**
+ * @vitest-environment jsdom
+ * Tests for client/src/ui/downloads.js
+ *
+ * Verifies DOM rendering functions for tag badges and client logos.
+ * Uses jsdom to create and assert DOM structure.
+ */
+
+import { renderTagBadges } from '../../../client/src/ui/downloads.js';
+
+describe('renderTagBadges', () => {
+  it('returns empty fragment when showAll is false and no matchedUserTag', () => {
+    const result = renderTagBadges([], false, null);
+    expect(result).toBeTruthy();
+    expect(result.childNodes.length).toBe(0);
+  });
+
+  it('returns empty fragment when tagBadges is empty', () => {
+    const result = renderTagBadges([], true, null);
+    expect(result).toBeTruthy();
+    expect(result.childNodes.length).toBe(0);
+  });
+
+  it('renders single matched badge when matchedUserTag is provided', () => {
+    const result = renderTagBadges([], false, 'user1');
+    expect(result.childNodes.length).toBe(1);
+    const badge = result.childNodes[0];
+    expect(badge.className).toBe('download-user-badge');
+    expect(badge.textContent).toBe('user1');
+  });
+
+  it('renders unmatched badges when showAll is true', () => {
+    const tagBadges = [{ label: 'tag1', matchedUser: null }];
+    const result = renderTagBadges(tagBadges, true, null);
+    expect(result.childNodes.length).toBe(1);
+    const badge = result.childNodes[0];
+    expect(badge.className).toBe('download-user-badge unmatched');
+    expect(badge.textContent).toBe('tag1');
+  });
+
+  it('renders matched badges when showAll is true', () => {
+    const tagBadges = [{ label: 'tag1', matchedUser: 'user1' }];
+    const result = renderTagBadges(tagBadges, true, null);
+    expect(result.childNodes.length).toBe(1);
+    const badge = result.childNodes[0];
+    expect(badge.className).toBe('download-user-badge');
+    expect(badge.textContent).toBe('user1');
+  });
+
+  it('renders multiple badges in correct order (unmatched first)', () => {
+    const tagBadges = [
+      { label: 'tag1', matchedUser: 'user1' },
+      { label: 'tag2', matchedUser: null }
+    ];
+    const result = renderTagBadges(tagBadges, true, null);
+    expect(result.childNodes.length).toBe(2);
+    expect(result.childNodes[0].textContent).toBe('tag2');
+    expect(result.childNodes[0].className).toBe('download-user-badge unmatched');
+    expect(result.childNodes[1].textContent).toBe('user1');
+    expect(result.childNodes[1].className).toBe('download-user-badge');
+  });
+
+  it('handles mixed matched and unmatched badges', () => {
+    const tagBadges = [
+      { label: 'tag1', matchedUser: null },
+      { label: 'tag2', matchedUser: 'user2' },
+      { label: 'tag3', matchedUser: null }
+    ];
+    const result = renderTagBadges(tagBadges, true, null);
+    expect(result.childNodes.length).toBe(3);
+    // Unmatched badges come first
+    expect(result.childNodes[0].className).toBe('download-user-badge unmatched');
+    expect(result.childNodes[0].textContent).toBe('tag1');
+    expect(result.childNodes[1].className).toBe('download-user-badge unmatched');
+    expect(result.childNodes[1].textContent).toBe('tag3');
+    // Matched badges come after
+    expect(result.childNodes[2].className).toBe('download-user-badge');
+    expect(result.childNodes[2].textContent).toBe('user2');
+  });
+
+  it('prefers matchedUserTag over tagBadges when showAll is false', () => {
+    const tagBadges = [{ label: 'tag1', matchedUser: 'user1' }];
+    const result = renderTagBadges(tagBadges, false, 'override');
+    expect(result.childNodes.length).toBe(1);
+    expect(result.childNodes[0].textContent).toBe('override');
+  });
+
+  it('handles null tagBadges gracefully', () => {
+    const result = renderTagBadges(null, true, null);
+    expect(result).toBeTruthy();
+    expect(result.childNodes.length).toBe(0);
+  });
+
+  it('handles undefined tagBadges gracefully', () => {
+    const result = renderTagBadges(undefined, true, null);
+    expect(result).toBeTruthy();
+    expect(result.childNodes.length).toBe(0);
+  });
+});
+
+import { createDownloadCard } from '../../../client/src/ui/downloads.js';
+import { state } from '../../../client/src/state.js';
+
+describe('createDownloadCard rendering details', () => {
+  let originalState;
+
+  beforeEach(() => {
+    originalState = { ...state };
+  });
+
+  afterEach(() => {
+    // Reset global state
+    Object.assign(state, originalState);
+  });
+
+  describe('createClientLogo and fallbacks', () => {
+    it('renders client logo img tag when client is configured', () => {
+      const dl = {
+        title: 'Test Download',
+        type: 'series',
+        client: 'qbittorrent',
+        instanceName: 'Qbit Main'
+      };
+
+      const card = createDownloadCard(dl);
+      const wrapper = card.querySelector('.download-client-logo-wrapper');
+      expect(wrapper).toBeTruthy();
+
+      const img = wrapper.querySelector('img.download-client-logo');
+      expect(img).toBeTruthy();
+      expect(img.src).toContain('/images/clients/qbittorrent.svg');
+      expect(img.alt).toBe('Qbit Main icon');
+    });
+
+    it('falls back to character avatar text on img load error', () => {
+      const dl = {
+        title: 'Test Download',
+        type: 'series',
+        client: 'transmission'
+      };
+
+      const card = createDownloadCard(dl);
+      const wrapper = card.querySelector('.download-client-logo-wrapper');
+      const img = wrapper.querySelector('img');
+
+      // Trigger the onerror event programmatically to simulate missing/broken SVG
+      img.onerror();
+
+      expect(wrapper.classList.contains('fallback')).toBe(true);
+      expect(wrapper.textContent).toBe('T');
+    });
+  });
+
+  describe('createServiceIcons deep-linking', () => {
+    it('renders Ombi icon link for all users when ombiLink exists', () => {
+      state.isAdmin = false; // Non-admin should still see Ombi icon
+
+      const dl = {
+        title: 'Mandalorian S01E01',
+        type: 'series',
+        seriesName: 'The Mandalorian',
+        ombiLink: 'https://ombi.test/request/42',
+        ombiTooltip: 'View on Ombi'
+      };
+
+      const card = createDownloadCard(dl);
+      const ombiLinkEl = card.querySelector('.download-series a');
+      expect(ombiLinkEl).toBeTruthy();
+      expect(ombiLinkEl.href).toBe('https://ombi.test/request/42');
+
+      const img = ombiLinkEl.querySelector('img.service-icon.ombi');
+      expect(img).toBeTruthy();
+      expect(img.title).toBe('View on Ombi');
+    });
+
+    it('renders Sonarr icon link for administrator when arrType is sonarr and arrLink exists', () => {
+      state.isAdmin = true; // Admin required for Sonarr link
+
+      const dl = {
+        title: 'Mandalorian S01E01',
+        type: 'series',
+        seriesName: 'The Mandalorian',
+        arrType: 'sonarr',
+        arrLink: 'https://sonarr.test/series/the-mandalorian'
+      };
+
+      const card = createDownloadCard(dl);
+      const arrLinkEl = card.querySelector('.download-series a');
+      expect(arrLinkEl).toBeTruthy();
+      expect(arrLinkEl.href).toBe('https://sonarr.test/series/the-mandalorian');
+
+      const img = arrLinkEl.querySelector('img.service-icon.sonarr');
+      expect(img).toBeTruthy();
+      expect(img.title).toBe('Sonarr');
+    });
+
+    it('renders Radarr icon link for administrator when arrType is radarr and arrLink exists', () => {
+      state.isAdmin = true; // Admin required for Radarr link
+
+      const dl = {
+        title: 'Blade Runner 2049',
+        type: 'movie',
+        movieName: 'Blade Runner 2049',
+        arrType: 'radarr',
+        arrLink: 'https://radarr.test/movie/blade-runner-2049'
+      };
+
+      const card = createDownloadCard(dl);
+      const arrLinkEl = card.querySelector('.download-movie a');
+      expect(arrLinkEl).toBeTruthy();
+      expect(arrLinkEl.href).toBe('https://radarr.test/movie/blade-runner-2049');
+
+      const img = arrLinkEl.querySelector('img.service-icon.radarr');
+      expect(img).toBeTruthy();
+      expect(img.title).toBe('Radarr');
+    });
+
+    it('does not render Sonarr/Radarr links if the user is a non-admin', () => {
+      state.isAdmin = false; // Non-admin
+
+      const dl = {
+        title: 'Mandalorian S01E01',
+        type: 'series',
+        seriesName: 'The Mandalorian',
+        arrType: 'sonarr',
+        arrLink: 'https://sonarr.test/series/the-mandalorian'
+      };
+
+      const card = createDownloadCard(dl);
+      const arrLinkEl = card.querySelector('.download-series a');
+      expect(arrLinkEl).toBeNull(); // Admin gate successfully hides Sonarr icon
+    });
+  });
+});
+