@muhammedaksam/easiarr 1.1.0 → 1.1.2

package/src/config/trash-quality-definitions.ts

@@ -0,0 +1,187 @@
+/**
+ * TRaSH Guides Quality Definitions (File Size Limits)
+ * Min/Preferred/Max in MB/min
+ * Source: ../Guides/docs/json/radarr/quality-size/movie.json
+ * Source: ../Guides/docs/json/sonarr/quality-size/series.json
+ */
+
+export interface TrashQualityDefinition {
+  quality: string
+  min: number
+  preferred: number
+  max: number
+}
+
+export const TRASH_RADARR_QUALITY_DEFINITIONS: TrashQualityDefinition[] = [
+  {
+    quality: "HDTV-720p",
+    min: 17.1,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBDL-720p",
+    min: 12.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBRip-720p",
+    min: 12.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "Bluray-720p",
+    min: 25.7,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "HDTV-1080p",
+    min: 33.8,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBDL-1080p",
+    min: 12.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBRip-1080p",
+    min: 12.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "Bluray-1080p",
+    min: 50.8,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "Remux-1080p",
+    min: 102,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "HDTV-2160p",
+    min: 85,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBDL-2160p",
+    min: 34.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "WEBRip-2160p",
+    min: 34.5,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "Bluray-2160p",
+    min: 102,
+    preferred: 1999,
+    max: 2000,
+  },
+  {
+    quality: "Remux-2160p",
+    min: 187.4,
+    preferred: 1999,
+    max: 2000,
+  },
+]
+
+export const TRASH_SONARR_QUALITY_DEFINITIONS: TrashQualityDefinition[] = [
+  {
+    quality: "HDTV-720p",
+    min: 10,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "HDTV-1080p",
+    min: 15,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBRip-720p",
+    min: 10,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBDL-720p",
+    min: 10,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "Bluray-720p",
+    min: 17.1,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBRip-1080p",
+    min: 15,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBDL-1080p",
+    min: 15,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "Bluray-1080p",
+    min: 50.4,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "Bluray-1080p Remux",
+    min: 69.1,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "HDTV-2160p",
+    min: 25,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBRip-2160p",
+    min: 25,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "WEBDL-2160p",
+    min: 25,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "Bluray-2160p",
+    min: 94.6,
+    preferred: 995,
+    max: 1000,
+  },
+  {
+    quality: "Bluray-2160p Remux",
+    min: 187.4,
+    preferred: 995,
+    max: 1000,
+  },
+]

package/src/ui/screens/FullAutoSetup.ts

@@ -12,6 +12,7 @@ import { ProwlarrClient, type ArrAppType } from "../../api/prowlarr-api"
 import { QBittorrentClient, type QBittorrentCategory } from "../../api/qbittorrent-api"
 import { PortainerApiClient } from "../../api/portainer-api"
 import { JellyfinClient } from "../../api/jellyfin-api"
+import { QualityProfileClient } from "../../api/quality-profile-api"
 import { JellyseerrClient } from "../../api/jellyseerr-api"
 import { CloudflareApi, setupCloudflaredTunnel } from "../../api/cloudflare-api"
 import { PlexApiClient } from "../../api/plex-api"
@@ -21,6 +22,7 @@ import { OverseerrClient } from "../../api/overseerr-api"
 import { TautulliClient } from "../../api/tautulli-api"
 import { HomarrClient } from "../../api/homarr-api"
 import { HeimdallClient } from "../../api/heimdall-api"
+import { HuntarrClient } from "../../api/huntarr-api"
 import { saveConfig } from "../../config"
 import { saveCompose } from "../../compose"
 import { getApp } from "../../apps/registry"
@@ -28,6 +30,7 @@ import { getApp } from "../../apps/registry"
 import { getCategoriesForApps } from "../../utils/categories"
 import { readEnvSync, updateEnv } from "../../utils/env"
 import { debugLog } from "../../utils/debug"
+import { getApplicationUrl } from "../../utils/url-utils"
 
 interface SetupStep {
   name: string
@@ -89,7 +92,10 @@ export class FullAutoSetup extends BoxRenderable {
   private initSteps(): void {
     this.steps = [
       { name: "Root Folders", status: "pending" },
+      { name: "Naming Scheme", status: "pending" },
+      { name: "Quality Settings", status: "pending" },
       { name: "Authentication", status: "pending" },
+      { name: "External URLs", status: "pending" },
       { name: "Prowlarr Apps", status: "pending" },
       { name: "FlareSolverr", status: "pending" },
       { name: "qBittorrent", status: "pending" },
@@ -104,6 +110,7 @@ export class FullAutoSetup extends BoxRenderable {
       { name: "Grafana", status: "pending" },
       { name: "Homarr", status: "pending" },
       { name: "Heimdall", status: "pending" },
+      { name: "Huntarr", status: "pending" },
       { name: "Cloudflare Tunnel", status: "pending" },
     ]
   }
@@ -138,52 +145,64 @@ export class FullAutoSetup extends BoxRenderable {
     // Step 1: Root folders
     await this.setupRootFolders()
 
-    // Step 2: Authentication
+    // Step 2: Naming Scheme
+    await this.setupNaming()
+
+    // Step 2b: Quality Settings
+    await this.setupQuality()
+
+    // Step 3: Authentication
     await this.setupAuthentication()
 
-    // Step 3: Prowlarr apps
+    // Step 3: External URLs
+    await this.setupExternalUrls()
+
+    // Step 4: Prowlarr apps
     await this.setupProwlarrApps()
 
-    // Step 4: FlareSolverr
+    // Step 5: FlareSolverr
     await this.setupFlareSolverr()
 
-    // Step 5: qBittorrent
+    // Step 6: qBittorrent
     await this.setupQBittorrent()
 
-    // Step 6: Portainer
+    // Step 7: Portainer
     await this.setupPortainer()
 
-    // Step 7: Jellyfin
+    // Step 8: Jellyfin
     await this.setupJellyfin()
 
-    // Step 8: Jellyseerr
+    // Step 9: Jellyseerr
     await this.setupJellyseerr()
 
-    // Step 9: Plex
+    // Step 10: Plex
     await this.setupPlex()
 
-    // Step 10: Overseerr (requires Plex)
+    // Step 11: Overseerr (requires Plex)
     await this.setupOverseerr()
 
-    // Step 11: Tautulli (Plex monitoring)
+    // Step 12: Tautulli (Plex monitoring)
     await this.setupTautulli()
 
-    // Step 12: Bazarr (subtitles)
+    // Step 13: Bazarr (subtitles)
     await this.setupBazarr()
 
-    // Step 13: Uptime Kuma (monitors)
+    // Step 14: Uptime Kuma (monitors)
     await this.setupUptimeKuma()
 
-    // Step 14: Grafana (dashboards)
+    // Step 15: Grafana (dashboards)
     await this.setupGrafana()
 
-    // Step 15: Homarr (dashboard)
+    // Step 16: Homarr (dashboard)
     await this.setupHomarr()
 
-    // Step 16: Heimdall (dashboard)
+    // Step 17: Heimdall (dashboard)
     await this.setupHeimdall()
 
-    // Step 17: Cloudflare Tunnel
+    // Step 18: Huntarr (*arr app manager)
+    await this.setupHuntarr()
+
+    // Step 19: Cloudflare Tunnel
     await this.setupCloudflare()
 
     this.isRunning = false
@@ -230,6 +249,74 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupNaming(): Promise<void> {
+    this.updateStep("Naming Scheme", "running")
+    this.refreshContent()
+
+    try {
+      const arrApps = this.config.apps.filter((a) => {
+        return a.enabled && (a.id === "radarr" || a.id === "sonarr")
+      })
+
+      for (const app of arrApps) {
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) continue
+
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const port = app.port || def.defaultPort
+        const client = new ArrApiClient("localhost", port, apiKey, def.rootFolder?.apiVersion || "v3")
+
+        try {
+          await client.configureTRaSHNaming(app.id as "radarr" | "sonarr")
+          debugLog("FullAutoSetup", `Configured naming for ${app.id}`)
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to configure naming for ${app.id}: ${e}`)
+        }
+      }
+
+      this.updateStep("Naming Scheme", "success")
+    } catch (e) {
+      this.updateStep("Naming Scheme", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
+  private async setupQuality(): Promise<void> {
+    this.updateStep("Quality Settings", "running")
+    this.refreshContent()
+
+    try {
+      const arrApps = this.config.apps.filter((a) => {
+        return a.enabled && (a.id === "radarr" || a.id === "sonarr")
+      })
+
+      for (const app of arrApps) {
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) continue
+
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const port = app.port || def.defaultPort
+        const client = new QualityProfileClient("localhost", port, apiKey)
+
+        try {
+          await client.updateTrashQualityDefinitions(app.id as "radarr" | "sonarr")
+          debugLog("FullAutoSetup", `Configured quality settings for ${app.id}`)
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to configure quality settings for ${app.id}: ${e}`)
+        }
+      }
+
+      this.updateStep("Quality Settings", "success")
+    } catch (e) {
+      this.updateStep("Quality Settings", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private async setupAuthentication(): Promise<void> {
     this.updateStep("Authentication", "running")
     this.refreshContent()
@@ -312,6 +399,10 @@ export class FullAutoSetup extends BoxRenderable {
               debugLog("FullAutoSetup", "Failed to configure Bazarr -> Sonarr connection")
             }
           }
+
+          // TRaSH Recommended Settings
+          await bazarrClient.configureGeneralSettings()
+          await bazarrClient.configureDefaultLanguageProfile()
         }
       }
 
@@ -322,6 +413,56 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupExternalUrls(): Promise<void> {
+    this.updateStep("External URLs", "running")
+    this.refreshContent()
+
+    let configured = 0
+
+    try {
+      // Configure *arr apps (Radarr, Sonarr, Lidarr, Readarr, Whisparr, Prowlarr)
+      const arrApps = this.config.apps.filter((a) => {
+        const def = getApp(a.id)
+        return a.enabled && (def?.rootFolder || a.id === "prowlarr")
+      })
+
+      for (const app of arrApps) {
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) {
+          continue
+        }
+
+        const port = app.port || def.defaultPort
+        const apiVersion = app.id === "prowlarr" ? "v1" : def.rootFolder?.apiVersion || "v3"
+        const client = new ArrApiClient("localhost", port, apiKey, apiVersion)
+
+        try {
+          const applicationUrl = getApplicationUrl(app.id, port, this.config)
+          await client.setApplicationUrl(applicationUrl)
+          debugLog("FullAutoSetup", `Set applicationUrl for ${app.id}: ${applicationUrl}`)
+          configured++
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to set applicationUrl for ${app.id}: ${e}`)
+        }
+      }
+
+      // Note: Jellyseerr and Overseerr are handled in their own setup steps
+      // (setupJellyseerr/setupOverseerr) because they require authentication first
+
+      if (configured > 0) {
+        this.updateStep("External URLs", "success", `${configured} apps configured`)
+      } else {
+        this.updateStep("External URLs", "skipped", "No apps with API keys")
+      }
+    } catch (e) {
+      this.updateStep("External URLs", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private async setupProwlarrApps(): Promise<void> {
     this.updateStep("Prowlarr Apps", "running")
     this.refreshContent()
@@ -576,12 +717,16 @@ export class FullAutoSetup extends BoxRenderable {
         if (radarrConfig && this.env["API_KEY_RADARR"]) {
           try {
             const radarrDef = getApp("radarr")
+            const radarrPort = radarrConfig.port || radarrDef?.defaultPort || 7878
+            const radarrExternalUrl = getApplicationUrl("radarr", radarrPort, this.config)
             await client.configureRadarr(
               "radarr",
-              radarrConfig.port || radarrDef?.defaultPort || 7878,
+              radarrPort,
               this.env["API_KEY_RADARR"],
-              radarrDef?.rootFolder?.path || "/data/media/movies"
+              radarrDef?.rootFolder?.path || "/data/media/movies",
+              radarrExternalUrl
             )
+            debugLog("FullAutoSetup", `Jellyseerr: Radarr externalUrl set to ${radarrExternalUrl}`)
           } catch {
             /* Radarr config failed */
           }
@@ -591,17 +736,43 @@ export class FullAutoSetup extends BoxRenderable {
         if (sonarrConfig && this.env["API_KEY_SONARR"]) {
           try {
             const sonarrDef = getApp("sonarr")
+            const sonarrPort = sonarrConfig.port || sonarrDef?.defaultPort || 8989
+            const sonarrExternalUrl = getApplicationUrl("sonarr", sonarrPort, this.config)
             await client.configureSonarr(
               "sonarr",
-              sonarrConfig.port || sonarrDef?.defaultPort || 8989,
+              sonarrPort,
               this.env["API_KEY_SONARR"],
-              sonarrDef?.rootFolder?.path || "/data/media/tv"
+              sonarrDef?.rootFolder?.path || "/data/media/tv",
+              sonarrExternalUrl
             )
+            debugLog("FullAutoSetup", `Jellyseerr: Sonarr externalUrl set to ${sonarrExternalUrl}`)
           } catch {
             /* Sonarr config failed */
           }
         }
 
+        // Set Jellyfin's externalHostname for navigation links
+        const jellyfinConfig = this.config.apps.find((a) => a.id === "jellyfin" && a.enabled)
+        if (jellyfinConfig) {
+          try {
+            const jellyfinPort = jellyfinConfig.port || 8096
+            const jellyfinUrl = getApplicationUrl("jellyfin", jellyfinPort, this.config)
+            await client.updateJellyfinSettings({ externalHostname: jellyfinUrl })
+            debugLog("FullAutoSetup", `Jellyseerr: Jellyfin externalHostname set to ${jellyfinUrl}`)
+          } catch {
+            debugLog("FullAutoSetup", "Failed to set Jellyfin externalHostname in Jellyseerr")
+          }
+        }
+
+        // Set Jellyseerr's own applicationUrl (we're already authenticated from setup)
+        try {
+          const jellyseerrUrl = getApplicationUrl("jellyseerr", port, this.config)
+          await client.setApplicationUrl(jellyseerrUrl)
+          debugLog("FullAutoSetup", `Jellyseerr: applicationUrl set to ${jellyseerrUrl}`)
+        } catch {
+          debugLog("FullAutoSetup", "Failed to set Jellyseerr applicationUrl")
+        }
+
         this.updateStep("Jellyseerr", "success", result.message)
       } else {
         this.updateStep("Jellyseerr", "skipped", result.message)
@@ -869,6 +1040,16 @@ export class FullAutoSetup extends BoxRenderable {
           await updateEnv(result.envUpdates)
           Object.assign(this.env, result.envUpdates)
         }
+
+        // Set Overseerr's applicationUrl (we're already authenticated from setup)
+        try {
+          const overseerrUrl = getApplicationUrl("overseerr", port, this.config)
+          await client.setApplicationUrl(overseerrUrl)
+          debugLog("FullAutoSetup", `Overseerr: applicationUrl set to ${overseerrUrl}`)
+        } catch {
+          debugLog("FullAutoSetup", "Failed to set Overseerr applicationUrl")
+        }
+
         this.updateStep("Overseerr", "success", result.message)
       } else {
         this.updateStep("Overseerr", "skipped", result.message)
@@ -1021,6 +1202,50 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupHuntarr(): Promise<void> {
+    this.updateStep("Huntarr", "running")
+    this.refreshContent()
+
+    const huntarrConfig = this.config.apps.find((a) => a.id === "huntarr" && a.enabled)
+    if (!huntarrConfig) {
+      this.updateStep("Huntarr", "skipped", "Not enabled")
+      this.refreshContent()
+      return
+    }
+
+    try {
+      const port = huntarrConfig.port || 9705
+      const client = new HuntarrClient("localhost", port)
+
+      // Check if reachable
+      const healthy = await client.isHealthy()
+      if (!healthy) {
+        this.updateStep("Huntarr", "skipped", "Not reachable yet")
+        this.refreshContent()
+        return
+      }
+
+      // Authenticate (creates user if needed, otherwise logs in)
+      const authenticated = await client.authenticate(this.globalUsername, this.globalPassword)
+      if (!authenticated) {
+        this.updateStep("Huntarr", "skipped", "Auth failed")
+        this.refreshContent()
+        return
+      }
+
+      // Add enabled *arr apps to Huntarr
+      try {
+        const result = await client.setupEasiarrApps(this.config.apps, this.env)
+        this.updateStep("Huntarr", "success", `${result.added} *arr apps added`)
+      } catch {
+        this.updateStep("Huntarr", "success", "Ready")
+      }
+    } catch (e) {
+      this.updateStep("Huntarr", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private async setupHeimdall(): Promise<void> {
     this.updateStep("Heimdall", "running")
     this.refreshContent()

package/src/ui/screens/TRaSHProfileSetup.ts

@@ -7,6 +7,7 @@ import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/c
 import { createPageLayout } from "../components/PageLayout"
 import { EasiarrConfig, AppId } from "../../config/schema"
 import { getApp } from "../../apps/registry"
+import { ArrApiClient } from "../../api/arr-api"
 import { QualityProfileClient } from "../../api/quality-profile-api"
 import { CustomFormatClient, getCFNamesForCategories } from "../../api/custom-format-api"
 import { getPresetsForApp, TRaSHProfilePreset } from "../../data/trash-profiles"
@@ -18,6 +19,7 @@ interface SetupResult {
   appName: string
   profile: string
   cfCount: number
+  namingConfigured: boolean
   status: "pending" | "configuring" | "success" | "error"
   message?: string
 }
@@ -185,6 +187,7 @@ export class TRaSHProfileSetup extends BoxRenderable {
         appName: appDef.name,
         profile: preset.name,
         cfCount: 0,
+        namingConfigured: false,
         status: "configuring",
       })
       this.refreshContent()
@@ -195,6 +198,7 @@ export class TRaSHProfileSetup extends BoxRenderable {
         if (result) {
           result.status = "success"
           result.cfCount = Object.keys(preset.cfScores).length
+          result.namingConfigured = true
         }
       } catch (error) {
         const result = this.results.find((r) => r.appId === appId)
@@ -237,6 +241,10 @@ export class TRaSHProfileSetup extends BoxRenderable {
 
     // Create quality profile
     await qpClient.createTRaSHProfile(preset.name, preset.cutoffQuality, preset.allowedQualities, preset.cfScores)
+
+    // Configure naming scheme
+    const arrClient = new ArrApiClient("localhost", port, apiKey, appDef.rootFolder?.apiVersion || "v3")
+    await arrClient.configureTRaSHNaming(appId as "radarr" | "sonarr")
   }
 
   private refreshContent(): void {
@@ -349,7 +357,7 @@ export class TRaSHProfileSetup extends BoxRenderable {
 
       let content = `${status} ${result.appName}: ${result.profile}`
       if (result.status === "success") {
-        content += ` (${result.cfCount} CF scores)`
+        content += ` (${result.cfCount} CF scores, naming configured)`
       }
       if (result.message) {
         content += ` - ${result.message}`

package/src/utils/url-utils.ts

@@ -0,0 +1,38 @@
+/**
+ * URL Utilities
+ * Functions for generating app URLs based on Traefik configuration
+ */
+
+import type { EasiarrConfig } from "../config/schema"
+import { getLocalIp } from "./env"
+
+/**
+ * Get the local URL for an app (http://LOCAL_IP:PORT)
+ */
+export function getLocalAppUrl(port: number): string {
+  const localIp = getLocalIp()
+  return `http://${localIp}:${port}`
+}
+
+/**
+ * Get the external URL for an app (https://APP.DOMAIN)
+ * Returns null if Traefik is not enabled
+ */
+export function getExternalAppUrl(appId: string, config: EasiarrConfig): string | null {
+  if (!config.traefik?.enabled || !config.traefik.domain) {
+    return null
+  }
+  return `https://${appId}.${config.traefik.domain}`
+}
+
+/**
+ * Get the appropriate applicationUrl based on Traefik status
+ * Returns external URL if Traefik enabled, otherwise local URL
+ */
+export function getApplicationUrl(appId: string, port: number, config: EasiarrConfig): string {
+  const externalUrl = getExternalAppUrl(appId, config)
+  if (externalUrl) {
+    return externalUrl
+  }
+  return getLocalAppUrl(port)
+}