@muhammedaksam/easiarr 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "TUI tool for generating docker-compose files for the *arr media ecosystem with 41 apps, TRaSH Guides best practices, VPN routing, and Traefik reverse proxy support",
   "module": "src/index.ts",
   "type": "module",

package/src/api/prowlarr-api.ts

@@ -14,6 +14,33 @@ export interface IndexerProxy {
   fields: { name: string; value: unknown }[]
 }
 
+export interface ProwlarrIndexerSchema {
+  id?: number
+  name: string
+  implementation: string
+  configContract: string
+  fields: { name: string; value?: unknown }[]
+  tags: number[]
+  enable: boolean
+  privacy: "public" | "private" | "semi-private"
+  protocol: "torrent" | "usenet"
+  priority: number
+  capabilities?: {
+    categories: { id: number; name: string; subCategories?: { id: number; name: string }[] }[]
+  }
+}
+
+export interface ProwlarrIndexer {
+  id?: number
+  name: string
+  fields: { name: string; value?: unknown }[]
+  tags: number[]
+  enable: boolean
+  protocol: string
+  implementation: string
+  configContract: string
+}
+
 export interface SyncProfile {
   id?: number
   name: string
@@ -188,6 +215,28 @@ export class ProwlarrClient {
     await this.request(`/indexerproxy/${id}`, { method: "DELETE" })
   }
 
+  // Indexer Management
+  async getIndexerSchemas(): Promise<ProwlarrIndexerSchema[]> {
+    return this.request<ProwlarrIndexerSchema[]>("/indexer/schema")
+  }
+
+  async getIndexers(): Promise<ProwlarrIndexer[]> {
+    return this.request<ProwlarrIndexer[]>("/indexer")
+  }
+
+  async createIndexer(indexer: ProwlarrIndexerSchema): Promise<ProwlarrIndexer> {
+    // Ensure required fields are set
+    const payload = {
+      ...indexer,
+      id: undefined, // Create new
+      appProfileId: 1, // Default profile
+    }
+    return this.request<ProwlarrIndexer>("/indexer", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+  }
+
   // Sync Profile management (aka App Sync Profile)
   async getSyncProfiles(): Promise<SyncProfile[]> {
     return this.request<SyncProfile[]>("/appsyncprofile")
@@ -258,23 +307,14 @@ export class ProwlarrClient {
     prowlarrUrl: string,
     appUrl: string,
     appApiKey: string,
-    syncLevel: "disabled" | "addOnly" | "fullSync" = "fullSync"
+    syncLevel: "disabled" | "addOnly" | "fullSync" = "fullSync",
+    syncCategories: number[] = []
   ): Promise<Application> {
-    // Default sync categories for each app type
-    // Radarr: Movies (2000, 2010, etc), Sonarr: TV (5000, 5010, etc)
-    // Lidarr: Audio (3000), Readarr: Books (7000, 8010)
-    const syncCategoriesMap: Record<ArrAppType, number[]> = {
-      Radarr: [2000, 2010, 2020, 2030, 2040, 2045, 2050, 2060, 2070, 2080],
-      Sonarr: [5000, 5010, 5020, 5030, 5040, 5045, 5050, 5060, 5070, 5080],
-      Lidarr: [3000, 3010, 3020, 3030, 3040],
-      Readarr: [7000, 7010, 7020, 7030, 8000, 8010, 8020],
-    }
-
     const fields: { name: string; value: unknown }[] = [
       { name: "prowlarrUrl", value: prowlarrUrl },
       { name: "baseUrl", value: appUrl },
       { name: "apiKey", value: appApiKey },
-      { name: "syncCategories", value: syncCategoriesMap[appType] || [] },
+      { name: "syncCategories", value: syncCategories },
     ]
 
     return this.request<Application>("/applications", {
@@ -309,7 +349,8 @@ export class ProwlarrClient {
     port: number,
     apiKey: string,
     prowlarrHost: string,
-    prowlarrPort: number
+    prowlarrPort: number,
+    syncCategories?: number[]
   ): Promise<Application> {
     const prowlarrUrl = `http://${prowlarrHost}:${prowlarrPort}`
     const appUrl = `http://${host}:${port}`
@@ -321,6 +362,398 @@ export class ProwlarrClient {
       return existing
     }
 
-    return this.addApplication(appType, appType, prowlarrUrl, appUrl, apiKey)
+    return this.addApplication(appType, appType, prowlarrUrl, appUrl, apiKey, "fullSync", syncCategories)
   }
 }
+
+export const PROWLARR_CATEGORIES = [
+  {
+    id: 1000,
+    name: "Console",
+    subCategories: [
+      {
+        id: 1010,
+        name: "Console/NDS",
+        subCategories: [],
+      },
+      {
+        id: 1020,
+        name: "Console/PSP",
+        subCategories: [],
+      },
+      {
+        id: 1030,
+        name: "Console/Wii",
+        subCategories: [],
+      },
+      {
+        id: 1040,
+        name: "Console/XBox",
+        subCategories: [],
+      },
+      {
+        id: 1050,
+        name: "Console/XBox 360",
+        subCategories: [],
+      },
+      {
+        id: 1060,
+        name: "Console/Wiiware",
+        subCategories: [],
+      },
+      {
+        id: 1070,
+        name: "Console/XBox 360 DLC",
+        subCategories: [],
+      },
+      {
+        id: 1080,
+        name: "Console/PS3",
+        subCategories: [],
+      },
+      {
+        id: 1090,
+        name: "Console/Other",
+        subCategories: [],
+      },
+      {
+        id: 1110,
+        name: "Console/3DS",
+        subCategories: [],
+      },
+      {
+        id: 1120,
+        name: "Console/PS Vita",
+        subCategories: [],
+      },
+      {
+        id: 1130,
+        name: "Console/WiiU",
+        subCategories: [],
+      },
+      {
+        id: 1140,
+        name: "Console/XBox One",
+        subCategories: [],
+      },
+      {
+        id: 1180,
+        name: "Console/PS4",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 2000,
+    name: "Movies",
+    subCategories: [
+      {
+        id: 2010,
+        name: "Movies/Foreign",
+        subCategories: [],
+      },
+      {
+        id: 2020,
+        name: "Movies/Other",
+        subCategories: [],
+      },
+      {
+        id: 2030,
+        name: "Movies/SD",
+        subCategories: [],
+      },
+      {
+        id: 2040,
+        name: "Movies/HD",
+        subCategories: [],
+      },
+      {
+        id: 2045,
+        name: "Movies/UHD",
+        subCategories: [],
+      },
+      {
+        id: 2050,
+        name: "Movies/BluRay",
+        subCategories: [],
+      },
+      {
+        id: 2060,
+        name: "Movies/3D",
+        subCategories: [],
+      },
+      {
+        id: 2070,
+        name: "Movies/DVD",
+        subCategories: [],
+      },
+      {
+        id: 2080,
+        name: "Movies/WEB-DL",
+        subCategories: [],
+      },
+      {
+        id: 2090,
+        name: "Movies/x265",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 3000,
+    name: "Audio",
+    subCategories: [
+      {
+        id: 3010,
+        name: "Audio/MP3",
+        subCategories: [],
+      },
+      {
+        id: 3020,
+        name: "Audio/Video",
+        subCategories: [],
+      },
+      {
+        id: 3030,
+        name: "Audio/Audiobook",
+        subCategories: [],
+      },
+      {
+        id: 3040,
+        name: "Audio/Lossless",
+        subCategories: [],
+      },
+      {
+        id: 3050,
+        name: "Audio/Other",
+        subCategories: [],
+      },
+      {
+        id: 3060,
+        name: "Audio/Foreign",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 4000,
+    name: "PC",
+    subCategories: [
+      {
+        id: 4010,
+        name: "PC/0day",
+        subCategories: [],
+      },
+      {
+        id: 4020,
+        name: "PC/ISO",
+        subCategories: [],
+      },
+      {
+        id: 4030,
+        name: "PC/Mac",
+        subCategories: [],
+      },
+      {
+        id: 4040,
+        name: "PC/Mobile-Other",
+        subCategories: [],
+      },
+      {
+        id: 4050,
+        name: "PC/Games",
+        subCategories: [],
+      },
+      {
+        id: 4060,
+        name: "PC/Mobile-iOS",
+        subCategories: [],
+      },
+      {
+        id: 4070,
+        name: "PC/Mobile-Android",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 5000,
+    name: "TV",
+    subCategories: [
+      {
+        id: 5010,
+        name: "TV/WEB-DL",
+        subCategories: [],
+      },
+      {
+        id: 5020,
+        name: "TV/Foreign",
+        subCategories: [],
+      },
+      {
+        id: 5030,
+        name: "TV/SD",
+        subCategories: [],
+      },
+      {
+        id: 5040,
+        name: "TV/HD",
+        subCategories: [],
+      },
+      {
+        id: 5045,
+        name: "TV/UHD",
+        subCategories: [],
+      },
+      {
+        id: 5050,
+        name: "TV/Other",
+        subCategories: [],
+      },
+      {
+        id: 5060,
+        name: "TV/Sport",
+        subCategories: [],
+      },
+      {
+        id: 5070,
+        name: "TV/Anime",
+        subCategories: [],
+      },
+      {
+        id: 5080,
+        name: "TV/Documentary",
+        subCategories: [],
+      },
+      {
+        id: 5090,
+        name: "TV/x265",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 6000,
+    name: "XXX",
+    subCategories: [
+      {
+        id: 6010,
+        name: "XXX/DVD",
+        subCategories: [],
+      },
+      {
+        id: 6020,
+        name: "XXX/WMV",
+        subCategories: [],
+      },
+      {
+        id: 6030,
+        name: "XXX/XviD",
+        subCategories: [],
+      },
+      {
+        id: 6040,
+        name: "XXX/x264",
+        subCategories: [],
+      },
+      {
+        id: 6045,
+        name: "XXX/UHD",
+        subCategories: [],
+      },
+      {
+        id: 6050,
+        name: "XXX/Pack",
+        subCategories: [],
+      },
+      {
+        id: 6060,
+        name: "XXX/ImageSet",
+        subCategories: [],
+      },
+      {
+        id: 6070,
+        name: "XXX/Other",
+        subCategories: [],
+      },
+      {
+        id: 6080,
+        name: "XXX/SD",
+        subCategories: [],
+      },
+      {
+        id: 6090,
+        name: "XXX/WEB-DL",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 7000,
+    name: "Books",
+    subCategories: [
+      {
+        id: 7010,
+        name: "Books/Mags",
+        subCategories: [],
+      },
+      {
+        id: 7020,
+        name: "Books/EBook",
+        subCategories: [],
+      },
+      {
+        id: 7030,
+        name: "Books/Comics",
+        subCategories: [],
+      },
+      {
+        id: 7040,
+        name: "Books/Technical",
+        subCategories: [],
+      },
+      {
+        id: 7050,
+        name: "Books/Other",
+        subCategories: [],
+      },
+      {
+        id: 7060,
+        name: "Books/Foreign",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 8000,
+    name: "Other",
+    subCategories: [
+      {
+        id: 8010,
+        name: "Other/Misc",
+        subCategories: [],
+      },
+      {
+        id: 8020,
+        name: "Other/Hashed",
+        subCategories: [],
+      },
+    ],
+  },
+  {
+    id: 0,
+    name: "Other",
+    subCategories: [
+      {
+        id: 10,
+        name: "Other/Misc",
+        subCategories: [],
+      },
+      {
+        id: 20,
+        name: "Other/Hashed",
+        subCategories: [],
+      },
+    ],
+  },
+]

package/src/api/qbittorrent-api.ts

@@ -178,21 +178,33 @@ export class QBittorrentClient {
 
   /**
    * Configure qBittorrent for TRaSH Guide compliance
-   * Sets proper save paths and creates categories based on enabled apps
+   * Sets proper save paths and creates categories based on enabled *arr apps
    * @param categories - Array of {name, savePath} for each enabled *arr app
+   * @param auth - Optional credentials to enforce (update username/password)
    */
-  async configureTRaSHCompliant(categories: QBittorrentCategory[] = []): Promise<void> {
+  async configureTRaSHCompliant(
+    categories: QBittorrentCategory[] = [],
+    auth?: { user: string; pass: string }
+  ): Promise<void> {
     debugLog("qBittorrent", "Configuring TRaSH-compliant settings")
 
     // 1. Set global preferences
     debugLog("qBittorrent", "Setting save_path to /data/torrents")
-    await this.setPreferences({
+    const prefs: Record<string, unknown> = {
       save_path: "/data/torrents",
       temp_path_enabled: false,
       auto_tmm_enabled: true,
       category_changed_tmm_enabled: true,
       save_path_changed_tmm_enabled: true,
-    })
+    }
+
+    if (auth) {
+      debugLog("qBittorrent", "Setting WebUI username/password")
+      prefs.web_ui_username = auth.user
+      prefs.web_ui_password = auth.pass
+    }
+
+    await this.setPreferences(prefs)
 
     // 2. Create categories for each enabled media type
     for (const cat of categories) {

package/src/apps/registry.ts

@@ -29,6 +29,7 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/movies",
       apiVersion: "v3",
     },
+    prowlarrCategoryIds: [2000, 2010, 2020, 2030, 2040, 2045, 2050, 2060, 2070, 2080, 2090],
   },
 
   sonarr: {
@@ -52,6 +53,7 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/tv",
       apiVersion: "v3",
     },
+    prowlarrCategoryIds: [5000, 5010, 5020, 5030, 5040, 5045, 5050, 5060, 5070, 5080, 5090],
   },
 
   lidarr: {
@@ -73,6 +75,7 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/music",
       apiVersion: "v1",
     },
+    prowlarrCategoryIds: [3000, 3010, 3020, 3030, 3040, 3050, 3060],
   },
 
   readarr: {
@@ -94,6 +97,7 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/books",
       apiVersion: "v1",
     },
+    prowlarrCategoryIds: [7000, 7010, 7020, 7030, 7040, 7050, 7060],
     arch: {
       deprecated: ["arm64", "arm32"],
       warning: "Readarr is deprecated - no ARM64 support (project abandoned by upstream)",
@@ -161,6 +165,7 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/adult",
       apiVersion: "v3",
     },
+    prowlarrCategoryIds: [6000, 6010, 6020, 6030, 6040, 6045, 6050, 6060, 6070, 6080, 6090],
   },
 
   audiobookshelf: {

package/src/config/schema.ts

@@ -152,6 +152,7 @@ export interface AppDefinition {
   cap_add?: string[]
   apiKeyMeta?: ApiKeyMeta
   rootFolder?: RootFolderMeta
+  prowlarrCategoryIds?: number[]
   /** Architecture compatibility info - omit if supports all */
   arch?: ArchCompatibility
 }

package/src/ui/screens/FullAutoSetup.ts

@@ -319,7 +319,7 @@ export class FullAutoSetup extends BoxRenderable {
         savePath: `/data/torrents/${cat.name}`,
       }))
 
-      await client.configureTRaSHCompliant(categories)
+      await client.configureTRaSHCompliant(categories, { user, pass })
       this.updateStep("qBittorrent", "success")
     } catch (e) {
       this.updateStep("qBittorrent", "error", `${e}`)

package/src/ui/screens/ProwlarrSetup.ts

@@ -3,11 +3,11 @@
  * Configures Prowlarr integration with *arr apps, FlareSolverr, and proxies
  */
 
-import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
+import { BoxRenderable, CliRenderer, TextRenderable, TextNodeRenderable, KeyEvent } from "@opentui/core"
 import { createPageLayout } from "../components/PageLayout"
 import { EasiarrConfig } from "../../config/schema"
 import { getApp } from "../../apps/registry"
-import { ProwlarrClient, ArrAppType } from "../../api/prowlarr-api"
+import { ProwlarrClient, ArrAppType, ProwlarrIndexerSchema, PROWLARR_CATEGORIES } from "../../api/prowlarr-api"
 import { readEnvSync } from "../../utils/env"
 import { debugLog } from "../../utils/debug"
 
@@ -17,7 +17,7 @@ interface SetupResult {
   message?: string
 }
 
-type Step = "menu" | "sync-apps" | "flaresolverr" | "sync-profiles" | "done"
+type Step = "menu" | "sync-apps" | "flaresolverr" | "sync-profiles" | "select-indexers" | "done"
 
 const ARR_APP_TYPES: Record<string, ArrAppType> = {
   radarr: "Radarr",
@@ -37,6 +37,9 @@ export class ProwlarrSetup extends BoxRenderable {
   private pageContainer!: BoxRenderable
   private menuIndex = 0
   private prowlarrClient: ProwlarrClient | null = null
+  private availableIndexers: ProwlarrIndexerSchema[] = []
+  private selectedIndexers: Set<number> = new Set() // Using index in availableIndexers array
+  private listScrollOffset = 0
 
   constructor(cliRenderer: CliRenderer, config: EasiarrConfig, onBack: () => void) {
     const { container: pageContainer, content: contentBox } = createPageLayout(cliRenderer, {
@@ -84,6 +87,8 @@ export class ProwlarrSetup extends BoxRenderable {
 
       if (this.currentStep === "menu") {
         this.handleMenuKeys(key)
+      } else if (this.currentStep === "select-indexers") {
+        this.handleIndexerSelectionKeys(key)
       } else if (this.currentStep === "done") {
         if (key.name === "return" || key.name === "escape") {
           this.currentStep = "menu"
@@ -121,6 +126,11 @@ export class ProwlarrSetup extends BoxRenderable {
         description: "Add Cloudflare bypass proxy",
         action: () => this.setupFlareSolverr(),
       },
+      {
+        name: "🔍 Add Public Indexers",
+        description: "Search and add public trackers",
+        action: () => this.searchIndexers(),
+      },
       {
         name: "📊 Create Sync Profiles",
         description: "Limited API indexer profiles",
@@ -179,7 +189,15 @@ export class ProwlarrSetup extends BoxRenderable {
         const port = app.port || appDef?.defaultPort || 7878
 
         // In Docker, use container names for inter-container communication
-        await this.prowlarrClient.addArrApp(appType, app.id, port, apiKey, "prowlarr", prowlarrPort)
+        await this.prowlarrClient.addArrApp(
+          appType,
+          app.id,
+          port,
+          apiKey,
+          "prowlarr",
+          prowlarrPort,
+          appDef?.prowlarrCategoryIds
+        )
 
         const result = this.results.find((r) => r.name === app.id)
         if (result) {
@@ -272,11 +290,118 @@ export class ProwlarrSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async searchIndexers(): Promise<void> {
+    if (!this.prowlarrClient) return
+
+    this.currentStep = "select-indexers"
+    this.results = [{ name: "Fetching indexers...", status: "configuring" }]
+    this.refreshContent()
+
+    try {
+      const schemas = await this.prowlarrClient.getIndexerSchemas()
+      this.availableIndexers = schemas
+        .filter((i) => i.privacy === "public" && i.enable)
+        // Sort by category count descending (most capable first)
+        .sort((a, b) => {
+          const infoA = (a.capabilities?.categories || []).length
+          const infoB = (b.capabilities?.categories || []).length
+          return infoB - infoA
+        })
+
+      this.selectedIndexers.clear()
+      this.menuIndex = 0
+      this.listScrollOffset = 0
+      this.results = []
+    } catch (error) {
+      this.results = [{ name: "Error", status: "error", message: String(error) }]
+      this.currentStep = "done"
+    }
+    this.refreshContent()
+  }
+
+  private handleIndexerSelectionKeys(key: KeyEvent): void {
+    if (this.results.length > 0) return // If actively adding
+
+    if (key.name === "up") {
+      this.menuIndex = Math.max(0, this.menuIndex - 1)
+      if (this.menuIndex < this.listScrollOffset) {
+        this.listScrollOffset = this.menuIndex
+      }
+      this.refreshContent()
+    } else if (key.name === "down") {
+      this.menuIndex = Math.min(this.availableIndexers.length - 1, this.menuIndex + 1)
+      // Visible items = height - header (approx 15)
+      const visibleItems = 15
+      if (this.menuIndex >= this.listScrollOffset + visibleItems) {
+        this.listScrollOffset = this.menuIndex - visibleItems + 1
+      }
+      this.refreshContent()
+    } else if (key.name === "space") {
+      if (this.selectedIndexers.has(this.menuIndex)) {
+        this.selectedIndexers.delete(this.menuIndex)
+      } else {
+        this.selectedIndexers.add(this.menuIndex)
+      }
+      this.refreshContent()
+    } else if (key.name === "return") {
+      this.addSelectedIndexers()
+    }
+  }
+
+  private async addSelectedIndexers(): Promise<void> {
+    const toAdd = Array.from(this.selectedIndexers).map((idx) => this.availableIndexers[idx])
+    if (toAdd.length === 0) return
+
+    this.results = toAdd.map((i) => ({ name: i.name, status: "pending" }))
+    this.refreshContent()
+
+    for (const indexer of toAdd) {
+      // Update UI
+      const res = this.results.find((r) => r.name === indexer.name)
+      if (res) res.status = "configuring"
+      this.refreshContent()
+
+      try {
+        if (!this.prowlarrClient) throw new Error("No client")
+
+        // Auto-add FlareSolverr tag if it exists
+        const tags = await this.prowlarrClient.getTags()
+        const fsTag = tags.find((t) => t.label.toLowerCase() === "flaresolverr")
+
+        if (fsTag) {
+          indexer.tags = indexer.tags || []
+          if (!indexer.tags.includes(fsTag.id)) {
+            indexer.tags.push(fsTag.id)
+          }
+        }
+
+        await this.prowlarrClient.createIndexer(indexer)
+        if (res) {
+          res.status = "success"
+          const extra = fsTag ? " + FlareSolverr" : ""
+          res.message = `Added with ${indexer.capabilities?.categories?.length || 0} categories${extra}`
+        }
+      } catch (e) {
+        if (res) {
+          res.status = "error"
+          res.message = String(e)
+        }
+      }
+      this.refreshContent()
+    }
+
+    // After done, stay on done screen
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
   private refreshContent(): void {
     this.contentBox.getChildren().forEach((child) => child.destroy())
 
     if (this.currentStep === "menu") {
       this.renderMenu()
+    } else if (this.currentStep === "select-indexers" && this.results.length === 0) {
+      this.renderIndexerSelection()
     } else {
       this.renderResults()
     }
@@ -370,6 +495,132 @@ export class ProwlarrSetup extends BoxRenderable {
     }
   }
 
+  private renderIndexerSelection(): void {
+    const visibleHeight = 15
+    const endIndex = Math.min(this.availableIndexers.length, this.listScrollOffset + visibleHeight)
+    const items = this.availableIndexers.slice(this.listScrollOffset, endIndex)
+
+    // Calculate active category IDs from selected apps
+    const activeCategoryIds = new Set<number>()
+    this.config.apps.forEach((app) => {
+      const def = getApp(app.id)
+      def?.prowlarrCategoryIds?.forEach((id) => activeCategoryIds.add(id))
+    })
+
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: `Select Indexers (Space to toggle, Enter to add):\n\n`,
+        fg: "#f1fa8c",
+      })
+    )
+    // Removed extra `})` and `)` here to fix syntax.
+    // The original instruction had an extra `})` and `)` after the first `this.contentBox.add` call.
+
+    items.forEach((idx, i) => {
+      const realIndex = this.listScrollOffset + i
+      const isSelected = this.selectedIndexers.has(realIndex)
+      const isCurrent = realIndex === this.menuIndex
+
+      const check = isSelected ? "[x]" : "[ ]"
+      const pointer = isCurrent ? "→" : " "
+
+      const cats = idx.capabilities?.categories || []
+
+      // Group capabilities
+      const groups = new Map<string, boolean>() // Name -> IsRelevant
+
+      // Helper to check relevance
+      const checkRel = (min: number, max: number) => [...activeCategoryIds].some((id) => id >= min && id < max)
+
+      // Map to track which badge colors to use
+      // We can pre-define colors or just cycle them, but for now let's keep the user's preferred colors if possible,
+      // or define a mapping.
+      const categoryColors: Record<string, { active: string; inactive: string }> = {
+        Movies: { active: "#00ffff", inactive: "#008b8b" },
+        TV: { active: "#ff00ff", inactive: "#8b008b" },
+        Audio: { active: "#00ff00", inactive: "#006400" },
+        Books: { active: "#50fa7b", inactive: "#00008b" },
+        XXX: { active: "#ff5555", inactive: "#8b0000" },
+        PC: { active: "#f8f8f2", inactive: "#6272a4" },
+        Console: { active: "#f1fa8c", inactive: "#8b8000" },
+        Other: { active: "#aaaaaa", inactive: "#555555" },
+      }
+
+      cats.forEach((c) => {
+        const id = c.id
+        let name = ""
+        let isRel = false
+
+        // Find parent category from static data
+        const parentCat = PROWLARR_CATEGORIES.find((pc) => {
+          // Check if id matches parent
+          if (pc.id === id) return true
+          // Check if id matches any subcategory
+          if (pc.subCategories?.some((sub) => sub.id === id)) return true
+          // Check range heuristic if needed, but the static data should cover known IDs
+          // Fallback to range check if no exact match found?
+          // Actually, the static data structure implies ranges (e.g. Movies 2000-2999)
+          // Let's use the ID ranges implied by the static data if possible, or just strict matching.
+          // The previous code used ranges. Let's try to match ranges based on the starting ID of the parent category.
+          // Assuming categories are 1000s blocks.
+          const rangeStart = Math.floor(pc.id / 1000) * 1000
+          if (id >= rangeStart && id < rangeStart + 1000) return true
+          return false
+        })
+
+        if (parentCat) {
+          name = parentCat.name
+          const rangeStart = Math.floor(parentCat.id / 1000) * 1000
+          isRel = checkRel(rangeStart, rangeStart + 1000)
+        }
+
+        if (name) {
+          groups.set(name, groups.get(name) || isRel)
+        }
+      })
+
+      const line = new TextRenderable(this.cliRenderer, { content: "" })
+      line.add(`${pointer} ${check} ${idx.name} `)
+
+      // Render Badge Helper
+      const addBadge = (name: string) => {
+        if (groups.has(name)) {
+          const isRel = groups.get(name)
+          const colors = categoryColors[name] || categoryColors["Other"]
+          const color = isRel ? colors.active : colors.inactive
+
+          const badge = new TextNodeRenderable({ fg: color })
+          badge.add(`[${name}] `)
+          if (isRel) {
+            badge.attributes = 1
+          } // Bold if supported/relevant
+
+          line.add(badge)
+        }
+      }
+
+      // Iterate through our static categories to render badges in order
+      PROWLARR_CATEGORIES.forEach((cat) => {
+        addBadge(cat.name)
+      })
+
+      line.add("\n")
+      line.fg = isCurrent ? "#ffffff" : isSelected ? "#50fa7b" : "#aaaaaa"
+
+      this.contentBox.add(line)
+    })
+
+    const remaining = this.availableIndexers.length - endIndex
+    if (remaining > 0) {
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: `... and ${remaining} more`,
+          fg: "#6272a4",
+        })
+      )
+    }
+  }
+
   private cleanup(): void {
     this.cliRenderer.keyInput.off("keypress", this.keyHandler)
     this.destroy()

package/src/ui/screens/QBittorrentSetup.ts

@@ -162,7 +162,7 @@ export class QBittorrentSetup extends BoxRenderable {
         savePath: `/data/torrents/${cat.name}`,
       }))
 
-      await client.configureTRaSHCompliant(categories)
+      await client.configureTRaSHCompliant(categories, { user: this.user, pass: this.pass })
 
       const catNames = categories.map((c) => c.name).join(", ") || "none"
       this.statusMessage = `✅ Done!\n\n  save_path: /data/torrents\n  Categories: ${catNames}\n\n  Press Enter to continue.`