@muhammedaksam/easiarr 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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/arr-api.ts

@@ -46,6 +46,7 @@ export interface RemotePathMapping {
 
 import type { AppId } from "../config/schema"
 import { getCategoryForApp, getCategoryFieldName } from "../utils/categories"
+import { TRASH_NAMING_CONFIG, type NamingConfig } from "./naming-config"
 
 // qBittorrent download client config
 export function createQBittorrentConfig(
@@ -239,11 +240,63 @@ export class ArrApiClient {
     })
   }
 
+  /**
+   * Set application URL for external access (e.g., from Jellyseerr/dashboard links)
+   * URL will be used when generating external links in the app
+   */
+  async setApplicationUrl(applicationUrl: string): Promise<HostConfig> {
+    const currentConfig = await this.getHostConfig()
+
+    const updatedConfig: HostConfig = {
+      ...currentConfig,
+      applicationUrl,
+    }
+
+    debugLog("ArrAPI", `Setting applicationUrl to: ${applicationUrl}`)
+
+    return this.request<HostConfig>("/config/host", {
+      method: "PUT",
+      body: JSON.stringify(updatedConfig),
+    })
+  }
+
   // Remote Path Mapping methods - for Docker path translation
+
   async getRemotePathMappings(): Promise<RemotePathMapping[]> {
     return this.request<RemotePathMapping[]>("/remotepathmapping")
   }
 
+  // Naming Configuration methods
+  async getNamingConfig<T extends NamingConfig>(): Promise<T> {
+    return this.request<T>("/config/naming")
+  }
+
+  async updateNamingConfig<T extends NamingConfig>(config: T): Promise<T> {
+    return this.request<T>("/config/naming", {
+      method: "PUT",
+      body: JSON.stringify(config),
+    })
+  }
+
+  async configureTRaSHNaming(appType: "radarr" | "sonarr"): Promise<void> {
+    try {
+      // 1. Get current configuration to preserve ID and other fields
+      const currentConfig = await this.getNamingConfig<NamingConfig & { id?: number }>()
+
+      // 2. Merge with TRaSH defaults
+      const trashConfig = TRASH_NAMING_CONFIG[appType]
+      const newConfig = {
+        ...currentConfig,
+        ...trashConfig,
+      }
+
+      // 3. Update configuration
+      await this.updateNamingConfig(newConfig)
+    } catch (e) {
+      throw new Error(`Failed to configure naming: ${e}`)
+    }
+  }
+
   async addRemotePathMapping(host: string, remotePath: string, localPath: string): Promise<RemotePathMapping> {
     return this.request<RemotePathMapping>("/remotepathmapping", {
       method: "POST",

package/src/api/bazarr-api.ts

@@ -6,6 +6,19 @@
 import { debugLog } from "../utils/debug"
 import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
 
+/**
+ * Bazarr Language Profile Structure
+ */
+export interface BazarrLanguageProfile {
+  name: string
+  cutoff: string
+  languages: {
+    code: string
+    forced: boolean
+    hi: boolean
+  }[]
+}
+
 /**
  * Bazarr System Settings (partial - auth related fields)
  */
@@ -232,6 +245,76 @@ export class BazarrApiClient implements IAutoSetupClient {
     }
   }
 
+  /**
+   * Configure General Settings (TRaSH Recommended)
+   */
+  async configureGeneralSettings(): Promise<boolean> {
+    try {
+      debugLog("Bazarr", "Configuring general settings")
+      await this.postForm("/system/settings", {
+        "settings-subtitles-use_embedded_subtitles": "true",
+        "settings-subtitles-autosearch": "true",
+        "settings-subtitles-path_mapping": "", // Empty = Alongside Media File
+      })
+      return true
+    } catch (e) {
+      debugLog("Bazarr", `Failed to configure general settings: ${e}`)
+      return false
+    }
+  }
+
+  /**
+   * Get all language profiles
+   */
+  async getLanguageProfiles(): Promise<BazarrLanguageProfile[]> {
+    return this.get<BazarrLanguageProfile[]>("/system/languages/profiles")
+  }
+
+  /**
+   * Configure Default Language Profile
+   * Creates an english profile if it doesn't exist
+   */
+  async configureDefaultLanguageProfile(name = "English", language = "en"): Promise<boolean> {
+    try {
+      debugLog("Bazarr", `Configuring language profile: ${name}`)
+
+      // Get existing profiles to check and to preserve them
+      const profiles = (await this.getLanguageProfiles()) || []
+      const existing = profiles.find((p) => p.name === name)
+
+      if (existing) {
+        debugLog("Bazarr", `Language profile '${name}' already exists`)
+        return true
+      }
+
+      const newProfile: BazarrLanguageProfile = {
+        name: name,
+        cutoff: language,
+        languages: [
+          {
+            code: language,
+            forced: false,
+            hi: false,
+          },
+        ],
+      }
+
+      profiles.push(newProfile)
+
+      // Update settings with the new list (serialized as JSON)
+      // Note: Bazarr expects 'languages_profiles' as a JSON string in the form data
+      await this.postForm("/system/settings", {
+        languages_profiles: JSON.stringify(profiles),
+      })
+
+      debugLog("Bazarr", `Created language profile: ${name}`)
+      return true
+    } catch (e) {
+      debugLog("Bazarr", `Failed to configure language profile: ${e}`)
+      return false
+    }
+  }
+
   /**
    * Run the auto-setup process for Bazarr
    */

package/src/api/jellyseerr-api.ts

@@ -237,6 +237,15 @@ export class JellyseerrClient implements IAutoSetupClient {
     })
   }
 
+  /**
+   * Set application URL for external access
+   * URL will be used for links to Jellyseerr from other apps
+   */
+  async setApplicationUrl(applicationUrl: string): Promise<JellyseerrMainSettings> {
+    debugLog("Jellyseerr", `Setting applicationUrl to: ${applicationUrl}`)
+    return this.updateMainSettings({ applicationUrl })
+  }
+
   // ==========================================
   // Jellyfin Configuration
   // ==========================================
@@ -383,6 +392,13 @@ export class JellyseerrClient implements IAutoSetupClient {
     })
   }
 
+  async updateRadarr(id: number, settings: Partial<JellyseerrRadarrSettings>): Promise<JellyseerrRadarrSettings> {
+    return this.request<JellyseerrRadarrSettings>(`/settings/radarr/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(settings),
+    })
+  }
+
   // ==========================================
   // Sonarr Configuration
   // ==========================================
@@ -411,6 +427,13 @@ export class JellyseerrClient implements IAutoSetupClient {
     })
   }
 
+  async updateSonarr(id: number, settings: Partial<JellyseerrSonarrSettings>): Promise<JellyseerrSonarrSettings> {
+    return this.request<JellyseerrSonarrSettings>(`/settings/sonarr/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(settings),
+    })
+  }
+
   // ==========================================
   // Full Setup Wizard
   // ==========================================
@@ -453,14 +476,32 @@ export class JellyseerrClient implements IAutoSetupClient {
 
   /**
    * Configure Radarr connection with auto-detection of profiles
+   * @param externalUrl - Optional external URL for navigation (e.g., https://radarr.example.com)
    */
   async configureRadarr(
     hostname: string,
     port: number,
     apiKey: string,
-    rootFolder: string
+    rootFolder: string,
+    externalUrl?: string
   ): Promise<JellyseerrRadarrSettings | null> {
     try {
+      // Check if Radarr is already configured
+      const existingConfigs = await this.getRadarrSettings()
+      const existingConfig = existingConfigs.find((c) => c.hostname === hostname && c.port === port)
+
+      if (existingConfig?.id) {
+        // Update existing configuration (just update externalUrl)
+        // Note: id must be excluded from body - it's read-only in the API
+        debugLog("Jellyseerr", `Updating existing Radarr config (id: ${existingConfig.id})`)
+        const { id, ...configWithoutId } = existingConfig
+        return await this.updateRadarr(id, {
+          ...configWithoutId,
+          externalUrl,
+        })
+      }
+
+      // Test connection and get profiles
       const testResult = await this.testRadarr({
         hostname,
         port,
@@ -487,6 +528,7 @@ export class JellyseerrClient implements IAutoSetupClient {
         is4k: false,
         minimumAvailability: "announced",
         isDefault: true,
+        externalUrl,
       })
     } catch (e) {
       debugLog("Jellyseerr", `Radarr config failed: ${e}`)
@@ -496,14 +538,32 @@ export class JellyseerrClient implements IAutoSetupClient {
 
   /**
    * Configure Sonarr connection with auto-detection of profiles
+   * @param externalUrl - Optional external URL for navigation (e.g., https://sonarr.example.com)
    */
   async configureSonarr(
     hostname: string,
     port: number,
     apiKey: string,
-    rootFolder: string
+    rootFolder: string,
+    externalUrl?: string
   ): Promise<JellyseerrSonarrSettings | null> {
     try {
+      // Check if Sonarr is already configured
+      const existingConfigs = await this.getSonarrSettings()
+      const existingConfig = existingConfigs.find((c) => c.hostname === hostname && c.port === port)
+
+      if (existingConfig?.id) {
+        // Update existing configuration (just update externalUrl)
+        // Note: id must be excluded from body - it's read-only in the API
+        debugLog("Jellyseerr", `Updating existing Sonarr config (id: ${existingConfig.id})`)
+        const { id, ...configWithoutId } = existingConfig
+        return await this.updateSonarr(id, {
+          ...configWithoutId,
+          externalUrl,
+        })
+      }
+
+      // Test connection and get profiles
       const testResult = await this.testSonarr({
         hostname,
         port,
@@ -530,6 +590,7 @@ export class JellyseerrClient implements IAutoSetupClient {
         is4k: false,
         enableSeasonFolders: true,
         isDefault: true,
+        externalUrl,
       })
     } catch (e) {
       debugLog("Jellyseerr", `Sonarr config failed: ${e}`)
@@ -550,10 +611,27 @@ export class JellyseerrClient implements IAutoSetupClient {
         return { success: false, message: "Jellyseerr not reachable" }
       }
 
+      // Get Jellyfin connection details from env
+      const jellyfinHost = env["JELLYFIN_HOST"] || "jellyfin"
+      const jellyfinPort = parseInt(env["JELLYFIN_PORT"] || "8096", 10)
+
       // Check if already initialized
       const initialized = await this.isInitialized()
       if (initialized) {
-        // Get API key from settings
+        // Authenticate first to get session cookie (needed for protected endpoints)
+        try {
+          await this.authenticateJellyfin(username, password, jellyfinHost, jellyfinPort)
+          debugLog("Jellyseerr", "Authenticated to already-initialized instance")
+        } catch (authError) {
+          debugLog("Jellyseerr", `Auth failed on initialized instance: ${authError}`)
+          // Still return success, just without API key access
+          return {
+            success: true,
+            message: "Already configured (could not authenticate)",
+          }
+        }
+
+        // Now we can access protected endpoints with our session cookie
         const settings = await this.getMainSettings()
         return {
           success: true,
@@ -563,11 +641,7 @@ export class JellyseerrClient implements IAutoSetupClient {
         }
       }
 
-      // Get Jellyfin connection details from env
-      const jellyfinHost = env["JELLYFIN_HOST"] || "jellyfin"
-      const jellyfinPort = parseInt(env["JELLYFIN_PORT"] || "8096", 10)
-
-      // Run the setup wizard
+      // Run the setup wizard (authenticates as part of setup)
       const apiKey = await this.runJellyfinSetup(jellyfinHost, jellyfinPort, username, password)
 
       // Mark as initialized

package/src/api/naming-config.ts

@@ -0,0 +1,67 @@
+export interface RadarrNamingConfig {
+  renameMovies: boolean
+  replaceIllegalCharacters: boolean
+  colonReplacementFormat: "dash" | "spaceDash" | "spaceDashSpace" | "smart" | "delete" | number
+  standardMovieFormat: string
+  movieFolderFormat: string
+  includeQuality: boolean
+  replaceSpaces: boolean
+}
+
+export interface SonarrNamingConfig {
+  renameEpisodes: boolean
+  replaceIllegalCharacters: boolean
+  colonReplacementFormat: "dash" | "spaceDash" | "spaceDashSpace" | "smart" | "delete" | number
+  multiEpisodeStyle: "extend" | "duplicate" | "repeat" | "scene" | "range" | "prefixedRange" | number
+  dailyEpisodeFormat: string
+  animeEpisodeFormat: string
+  seriesFolderFormat: string
+  seasonFolderFormat: string
+  standardEpisodeFormat: string
+  includeSeriesTitle: boolean
+  includeEpisodeTitle: boolean
+  includeQuality: boolean
+  replaceSpaces: boolean
+  separator: string
+  numberStyle: string
+}
+
+export type NamingConfig = RadarrNamingConfig | SonarrNamingConfig
+
+// TRaSH Guides Recommended Naming Schemes
+// Source: https://trash-guides.info/Radarr/Radarr-recommended-naming-scheme/
+// Source: https://trash-guides.info/Sonarr/Sonarr-recommended-naming-scheme/
+
+export const TRASH_NAMING_CONFIG = {
+  radarr: {
+    renameMovies: true,
+    replaceIllegalCharacters: true,
+    colonReplacementFormat: "dash",
+    standardMovieFormat:
+      "{Movie CleanTitle} ({Release Year}) {edition-{Edition Tags}} {[Custom Formats]}{[Quality Full]}{[MediaInfo 3D]}{[Mediainfo AudioCodec}{ Mediainfo AudioChannels]}{[MediaInfo VideoDynamicRangeType]}{[Mediainfo VideoCodec]}{-Release Group}",
+    movieFolderFormat: "{Movie CleanTitle} ({Release Year})",
+    includeQuality: true,
+    replaceSpaces: false,
+  } as RadarrNamingConfig,
+
+  sonarr: {
+    renameEpisodes: true,
+    replaceIllegalCharacters: true,
+    colonReplacementFormat: 1, // 1 = Dash
+    multiEpisodeStyle: 5, // 5 = Prefixed Range
+    standardEpisodeFormat:
+      "{Series TitleYear} - S{season:00}E{episode:00} - {Episode CleanTitle} {[Custom Formats]}{[Quality Full]}{[Mediainfo AudioCodec}{ Mediainfo AudioChannels]}{[MediaInfo VideoDynamicRangeType]}{[Mediainfo VideoCodec]}{-Release Group}",
+    dailyEpisodeFormat:
+      "{Series TitleYear} - {Air-Date} - {Episode CleanTitle} {[Custom Formats]}{[Quality Full]}{[MediaInfo 3D]}{[Mediainfo AudioCodec}{ Mediainfo AudioChannels]}{[MediaInfo VideoDynamicRangeType]}{[Mediainfo VideoCodec]}{-Release Group}",
+    animeEpisodeFormat:
+      "{Series TitleYear} - S{season:00}E{episode:00} - {absolute:000} - {Episode CleanTitle} {[Custom Formats]}{[Quality Full]}{[MediaInfo 3D]}{[Mediainfo AudioCodec}{ Mediainfo AudioChannels]}{MediaInfo AudioLanguages}{[MediaInfo VideoDynamicRangeType]}[{Mediainfo VideoCodec }{MediaInfo VideoBitDepth}bit]{-Release Group}",
+    seriesFolderFormat: "{Series TitleYear}",
+    seasonFolderFormat: "Season {season:00}",
+    includeSeriesTitle: true,
+    includeEpisodeTitle: true,
+    includeQuality: true,
+    replaceSpaces: false,
+    separator: " - ",
+    numberStyle: "S{season:00}E{episode:00}",
+  } as SonarrNamingConfig,
+}

package/src/api/overseerr-api.ts

@@ -254,6 +254,30 @@ export class OverseerrClient implements IAutoSetupClient {
     return null
   }
 
+  /**
+   * Set application URL for external access
+   * URL will be used for links to Overseerr from other apps
+   */
+  async setApplicationUrl(applicationUrl: string): Promise<boolean> {
+    debugLog("OverseerrApi", `Setting applicationUrl to: ${applicationUrl}`)
+
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/settings/main`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ applicationUrl }),
+      })
+
+      if (response.ok) {
+        debugLog("OverseerrApi", "Application URL set successfully")
+        return true
+      }
+    } catch (error) {
+      debugLog("OverseerrApi", `Failed to set application URL: ${error}`)
+    }
+    return false
+  }
+
   /**
    * Sync Plex libraries
    */

package/src/api/qbittorrent-api.ts

@@ -14,6 +14,33 @@ export interface QBittorrentPreferences {
   auto_tmm_enabled?: boolean
   category_changed_tmm_enabled?: boolean
   save_path_changed_tmm_enabled?: boolean
+  max_ratio?: number
+  max_ratio_enabled?: boolean
+  max_ratio_act?: number // 0 = Pause, 1 = Remove
+  max_seeding_time?: number
+  max_seeding_time_enabled?: boolean
+  queueing_enabled?: boolean
+  web_ui_username?: string
+  web_ui_password?: string
+  // Connection & Speed
+  listen_port?: number
+  upnp?: boolean
+  natpmp?: boolean
+  dl_limit?: number
+  up_limit?: number
+  limit_utp_rate?: boolean
+  limit_tcp_overhead?: boolean
+  limit_lan_peers?: boolean
+  // Bittorrent
+  enable_dht?: boolean
+  enable_pex?: boolean
+  enable_lsd?: boolean
+  encryption_mode?: number // 0=Prefer, 1=Force, 2=Allow (check API docs for exact enum, typically 1=Force or Allow)
+  anonymous_mode?: boolean
+  add_trackers_enabled?: boolean
+  pre_allocate_all?: boolean
+  incomplete_files_ext?: boolean
+  create_subfolder_enabled?: boolean
 }
 
 export interface QBittorrentCategory {
@@ -197,6 +224,37 @@ export class QBittorrentClient implements IAutoSetupClient {
       auto_tmm_enabled: true,
       category_changed_tmm_enabled: true,
       save_path_changed_tmm_enabled: true,
+
+      // Downloads
+      pre_allocate_all: false, // Recommended disabled for unRaid/cache drives, safe default
+      incomplete_files_ext: true, // Recommended: Enabled
+      create_subfolder_enabled: true, // Recommended: Enabled
+
+      // Connection
+      upnp: false, // Recommended: Disabled (use manual port forward)
+      natpmp: false, // Recommended: Disabled
+
+      // Speed
+      dl_limit: -1, // Unlimited
+      up_limit: -1, // Unlimited (User should tune if needed)
+      limit_utp_rate: true, // Recommended: Enabled
+      limit_tcp_overhead: false, // Recommended: Disabled
+      limit_lan_peers: true, // Recommended: Enabled
+
+      // Bittorrent
+      enable_dht: true, // Implied enabled
+      enable_pex: true, // Implied enabled
+      enable_lsd: true, // Implied enabled
+      encryption_mode: 0, // 0 = Prefer Encryption (closest to "Allow encryption" usually, need to verify enum. 1=Force, 2=None usually. Let's assume 0 is safe/default or check docs if possible. TRaSH says "Allow encryption")
+      anonymous_mode: false, // Recommended: Disabled
+      add_trackers_enabled: false, // Recommended: Disabled for private trackers
+      queueing_enabled: true, // Recommended: Personal preference, enabled by default
+
+      // Seeding Limits (TRaSH Recommended: Disable globally)
+      max_ratio: -1, // -1 = Unlimited
+      max_ratio_enabled: false,
+      max_seeding_time_enabled: false,
+      max_ratio_act: 0, // 0 = Pause (Safe fallback)
     }
 
     if (auth) {

package/src/api/quality-profile-api.ts

@@ -3,6 +3,9 @@
  * Manages Quality Profiles and Custom Format scoring for Radarr/Sonarr
  */
 
+import { debugLog } from "../utils/debug"
+import { TRASH_RADARR_QUALITY_DEFINITIONS, TRASH_SONARR_QUALITY_DEFINITIONS } from "../config/trash-quality-definitions"
+
 export interface QualityItem {
   id?: number
   name?: string
@@ -112,10 +115,23 @@ export class QualityProfileClient {
   }
 
   async updateQualityDefinitions(definitions: QualityDefinition[]): Promise<QualityDefinition[]> {
-    return this.request<QualityDefinition[]>("/qualitydefinition/update", {
-      method: "PUT",
-      body: JSON.stringify(definitions),
-    })
+    const updated: QualityDefinition[] = []
+
+    // Update each definition individually as bulk update is not reliably supported across all versions
+    for (const def of definitions) {
+      if (!def.id) continue
+
+      try {
+        const result = await this.request<QualityDefinition>(`/qualitydefinition/${def.id}`, {
+          method: "PUT",
+          body: JSON.stringify(def),
+        })
+        updated.push(result)
+      } catch (e) {
+        debugLog("QualityProfile", `Failed to update definition ${def.id}: ${e}`)
+      }
+    }
+    return updated
   }
 
   // Helper: Get quality by name from existing profiles
@@ -202,4 +218,38 @@ export class QualityProfileClient {
 
     return this.updateQualityProfile(profileId, profile)
   }
+
+  // Apply TRaSH Quality Definitions (File Size Limits)
+  async updateTrashQualityDefinitions(appType: "radarr" | "sonarr"): Promise<void> {
+    try {
+      debugLog("QualityProfile", `Updating Quality Definitions for ${appType}`)
+      const definitions = await this.getQualityDefinitions()
+      const trashDefs = appType === "radarr" ? TRASH_RADARR_QUALITY_DEFINITIONS : TRASH_SONARR_QUALITY_DEFINITIONS
+      let updatedCount = 0
+
+      const newDefinitions = definitions.map((def) => {
+        const trashDef = trashDefs.find((t) => t.quality === def.quality.name)
+        if (trashDef) {
+          updatedCount++
+          return {
+            ...def,
+            minSize: trashDef.min,
+            maxSize: trashDef.max,
+            preferredSize: trashDef.preferred,
+          }
+        }
+        return def
+      })
+
+      if (updatedCount > 0) {
+        await this.updateQualityDefinitions(newDefinitions)
+        debugLog("QualityProfile", `Successfully updated ${updatedCount} quality definitions`)
+      } else {
+        debugLog("QualityProfile", "No matching quality definitions found to update")
+      }
+    } catch (e) {
+      debugLog("QualityProfile", `Failed to update quality definitions: ${e}`)
+      throw e
+    }
+  }
 }

package/src/apps/registry.ts

@@ -248,6 +248,17 @@ export const APPS: Record<AppId, AppDefinition> = {
       LOG_HTML: "false",
       CAPTCHA_SOLVER: "none",
     },
+    homepage: {
+      icon: "flaresolverr.png",
+      widget: "customapi",
+      widgetFields: {
+        url: "http://flaresolverr:8191",
+        mappings: JSON.stringify([
+          { field: "msg", label: "Status" },
+          { field: "version", label: "Version" },
+        ]),
+      },
+    },
   },
 
   // === DOWNLOAD CLIENTS ===
@@ -647,7 +658,10 @@ export const APPS: Record<AppId, AppDefinition> = {
       widget: "customapi",
       widgetFields: {
         url: "http://easiarr:8080/config.json",
-        mappings: JSON.stringify([{ field: "version", label: "Installed" }]),
+        mappings: JSON.stringify([
+          { field: "version", label: "Version" },
+          { field: "apps.length", label: "Apps" },
+        ]),
       },
     },
   },

package/src/config/homepage-config.ts

@@ -24,7 +24,7 @@ export function getHomepageConfigPath(config: EasiarrConfig): string {
  * Homepage service entry
  */
 interface HomepageService {
-  href: string
+  href?: string // Optional - cloudflared has no web UI
   icon?: string
   description?: string
   ping?: string
@@ -63,10 +63,22 @@ export async function generateServicesYaml(config: EasiarrConfig): Promise<strin
     const dockerUrl = `http://${appDef.id}:${internalPort}`
 
     const service: HomepageService = {
-      href: baseUrl,
       description: appDef.description,
     }
 
+    // Special cases for href/ping
+    if (appDef.id === "cloudflared") {
+      // Cloudflared has no web UI - skip href/ping
+    } else if (appDef.id === "traefik") {
+      // Traefik dashboard is on port 8083 (secondary port), not 80 (proxy)
+      const dashboardUrl = `http://${localIp}:8083`
+      service.href = dashboardUrl
+      service.ping = dashboardUrl
+    } else {
+      service.href = baseUrl
+      service.ping = baseUrl
+    }
+
     // Add icon if defined in homepage meta
     if (appDef.homepage?.icon) {
       service.icon = appDef.homepage.icon
@@ -75,9 +87,6 @@ export async function generateServicesYaml(config: EasiarrConfig): Promise<strin
       service.icon = `${appDef.id}.png`
     }
 
-    // Add ping for monitoring
-    service.ping = baseUrl
-
     // Add widget if defined
     if (appDef.homepage?.widget) {
       const apiKey = env[`API_KEY_${appDef.id.toUpperCase()}`]
@@ -114,7 +123,10 @@ export async function generateServicesYaml(config: EasiarrConfig): Promise<strin
         // Skip widget if no API key
       }
       // Most widgets need API key - only add if available
-      else if (apiKey || ["qbittorrent", "gluetun", "traefik", "huntarr"].includes(appDef.id)) {
+      else if (
+        apiKey ||
+        ["qbittorrent", "gluetun", "traefik", "huntarr", "easiarr", "flaresolverr"].includes(appDef.id)
+      ) {
         service.widget = {
           type: widgetType,
           url: dockerUrl,
@@ -236,7 +248,10 @@ export async function generateServicesYaml(config: EasiarrConfig): Promise<strin
 
     for (const { name, service } of services) {
       yaml += `    - ${name}:\n`
-      yaml += `        href: ${service.href}\n`
+
+      if (service.href) {
+        yaml += `        href: ${service.href}\n`
+      }
 
       if (service.icon) {
         yaml += `        icon: ${service.icon}\n`
@@ -253,7 +268,9 @@ export async function generateServicesYaml(config: EasiarrConfig): Promise<strin
       if (service.widget) {
         yaml += `        widget:\n`
         yaml += `          type: ${service.widget.type}\n`
-        yaml += `          url: ${service.widget.url}\n`
+        if (service.widget.url) {
+          yaml += `          url: ${service.widget.url}\n`
+        }
 
         if (service.widget.key) {
           yaml += `          key: ${service.widget.key}\n`

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"
@@ -29,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
@@ -90,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" },
@@ -140,55 +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: Huntarr (*arr app manager)
+    // Step 18: Huntarr (*arr app manager)
     await this.setupHuntarr()
 
-    // Step 18: Cloudflare Tunnel
+    // Step 19: Cloudflare Tunnel
     await this.setupCloudflare()
 
     this.isRunning = false
@@ -235,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()
@@ -317,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()
         }
       }
 
@@ -327,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()
@@ -581,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 */
           }
@@ -596,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)
@@ -874,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)

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)
+}