@muhammedaksam/easiarr 0.2.0 → 0.3.1

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

@@ -0,0 +1,205 @@
+/**
+ * Quality Profile API Client
+ * Manages Quality Profiles and Custom Format scoring for Radarr/Sonarr
+ */
+
+export interface QualityItem {
+  id?: number
+  name?: string
+  quality?: {
+    id: number
+    name: string
+    source: string
+    resolution: number
+  }
+  items?: QualityItem[]
+  allowed: boolean
+}
+
+export interface FormatItem {
+  format: number
+  name?: string
+  score: number
+}
+
+export interface QualityProfile {
+  id?: number
+  name: string
+  upgradeAllowed: boolean
+  cutoff: number
+  minFormatScore: number
+  cutoffFormatScore: number
+  formatItems: FormatItem[]
+  language?: { id: number; name: string }
+  items: QualityItem[]
+}
+
+export interface QualityDefinition {
+  id: number
+  quality: {
+    id: number
+    name: string
+    source: string
+    resolution: number
+  }
+  title: string
+  weight: number
+  minSize: number
+  maxSize: number
+  preferredSize: number
+}
+
+export class QualityProfileClient {
+  private baseUrl: string
+  private apiKey: string
+  private apiVersion: string
+
+  constructor(host: string, port: number, apiKey: string, apiVersion = "v3") {
+    this.baseUrl = `http://${host}:${port}/api/${apiVersion}`
+    this.apiKey = apiKey
+    this.apiVersion = apiVersion
+  }
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    const headers: Record<string, string> = {
+      "X-Api-Key": this.apiKey,
+      "Content-Type": "application/json",
+      ...((options.headers as Record<string, string>) || {}),
+    }
+
+    const response = await fetch(url, { ...options, headers })
+
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status} ${response.statusText}`)
+    }
+
+    const text = await response.text()
+    if (!text) return {} as T
+    return JSON.parse(text) as T
+  }
+
+  // Quality Profile methods
+  async getQualityProfiles(): Promise<QualityProfile[]> {
+    return this.request<QualityProfile[]>("/qualityprofile")
+  }
+
+  async getQualityProfile(id: number): Promise<QualityProfile> {
+    return this.request<QualityProfile>(`/qualityprofile/${id}`)
+  }
+
+  async createQualityProfile(profile: Omit<QualityProfile, "id">): Promise<QualityProfile> {
+    return this.request<QualityProfile>("/qualityprofile", {
+      method: "POST",
+      body: JSON.stringify(profile),
+    })
+  }
+
+  async updateQualityProfile(id: number, profile: QualityProfile): Promise<QualityProfile> {
+    return this.request<QualityProfile>(`/qualityprofile/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ ...profile, id }),
+    })
+  }
+
+  async deleteQualityProfile(id: number): Promise<void> {
+    await this.request(`/qualityprofile/${id}`, { method: "DELETE" })
+  }
+
+  // Quality Definition methods (for size limits)
+  async getQualityDefinitions(): Promise<QualityDefinition[]> {
+    return this.request<QualityDefinition[]>("/qualitydefinition")
+  }
+
+  async updateQualityDefinitions(definitions: QualityDefinition[]): Promise<QualityDefinition[]> {
+    return this.request<QualityDefinition[]>("/qualitydefinition/update", {
+      method: "PUT",
+      body: JSON.stringify(definitions),
+    })
+  }
+
+  // Helper: Get quality by name from existing profiles
+  async getQualityIdByName(name: string): Promise<number | null> {
+    const profiles = await this.getQualityProfiles()
+    if (profiles.length === 0) return null
+
+    const findQuality = (items: QualityItem[]): number | null => {
+      for (const item of items) {
+        if (item.quality?.name === name) return item.quality.id
+        if (item.items) {
+          const found = findQuality(item.items)
+          if (found !== null) return found
+        }
+      }
+      return null
+    }
+
+    return findQuality(profiles[0].items)
+  }
+
+  // Create TRaSH-recommended profile
+  async createTRaSHProfile(
+    name: string,
+    cutoffQualityName: string,
+    allowedQualities: string[],
+    cfScores: Record<string, number> = {}
+  ): Promise<QualityProfile> {
+    // Get existing profile to clone quality structure
+    const existingProfiles = await this.getQualityProfiles()
+    if (existingProfiles.length === 0) {
+      throw new Error("No existing profiles to clone quality structure from")
+    }
+
+    const baseProfile = existingProfiles[0]
+    const cutoffId = await this.getQualityIdByName(cutoffQualityName)
+
+    if (cutoffId === null) {
+      throw new Error(`Quality "${cutoffQualityName}" not found`)
+    }
+
+    // Build quality items with allowed flags
+    const setAllowed = (items: QualityItem[]): QualityItem[] => {
+      return items.map((item) => {
+        if (item.items) {
+          return { ...item, items: setAllowed(item.items) }
+        }
+        return {
+          ...item,
+          allowed: item.quality ? allowedQualities.includes(item.quality.name) : false,
+        }
+      })
+    }
+
+    // Get custom formats and map scores
+    const formatItems: FormatItem[] = baseProfile.formatItems.map((fi) => ({
+      format: fi.format,
+      name: fi.name,
+      score: cfScores[fi.name || ""] ?? 0,
+    }))
+
+    const newProfile: Omit<QualityProfile, "id"> = {
+      name,
+      upgradeAllowed: true,
+      cutoff: cutoffId,
+      minFormatScore: 0,
+      cutoffFormatScore: 10000,
+      formatItems,
+      language: baseProfile.language,
+      items: setAllowed(baseProfile.items),
+    }
+
+    return this.createQualityProfile(newProfile)
+  }
+
+  // Update CF scores on existing profile
+  async updateProfileCFScores(profileId: number, cfScores: Record<string, number>): Promise<QualityProfile> {
+    const profile = await this.getQualityProfile(profileId)
+
+    profile.formatItems = profile.formatItems.map((fi) => ({
+      ...fi,
+      score: cfScores[fi.name || ""] ?? fi.score,
+    }))
+
+    return this.updateQualityProfile(profileId, profile)
+  }
+}

package/src/apps/registry.ts

@@ -138,10 +138,8 @@ export const APPS: Record<AppId, AppDefinition> = {
       enabledKey: "api_enabled",
       generateIfMissing: true,
     },
-    rootFolder: {
-      path: "/data/media/comics",
-      apiVersion: "v1",
-    },
+    // Note: Mylar3 is NOT an *arr app - has different API format (?cmd=<endpoint>)
+    // Root folder is configured via Web UI settings, not API
   },
 
   whisparr: {

package/src/data/trash-profiles.ts

@@ -0,0 +1,252 @@
+/**
+ * TRaSH Guide Quality Profile Presets
+ * Pre-configured quality profiles based on TRaSH Guides recommendations
+ */
+
+export interface TRaSHProfilePreset {
+  id: string
+  name: string
+  description: string
+  app: "radarr" | "sonarr" | "both"
+  cutoffQuality: string
+  allowedQualities: string[]
+  cfScores: Record<string, number>
+}
+
+// Quality names for different resolutions
+export const RADARR_QUALITIES = {
+  // HD
+  "Bluray-1080p": "Bluray-1080p",
+  "WEB-1080p": "WEBDL-1080p",
+  "HDTV-1080p": "HDTV-1080p",
+  "Bluray-720p": "Bluray-720p",
+  "WEB-720p": "WEBDL-720p",
+  // UHD
+  "Bluray-2160p": "Bluray-2160p",
+  "WEB-2160p": "WEBDL-2160p",
+  // Remux
+  "Remux-1080p": "Remux-1080p",
+  "Remux-2160p": "Remux-2160p",
+}
+
+export const SONARR_QUALITIES = {
+  "WEB-1080p": "WEBDL-1080p",
+  "WEB-720p": "WEBDL-720p",
+  "WEB-2160p": "WEBDL-2160p",
+  "HDTV-1080p": "HDTV-1080p",
+  "HDTV-720p": "HDTV-720p",
+  "Bluray-1080p": "Bluray-1080p",
+  "Bluray-720p": "Bluray-720p",
+  "Bluray-2160p": "Bluray-2160p",
+  "Remux-1080p": "Remux-1080p",
+  "Remux-2160p": "Remux-2160p",
+}
+
+// TRaSH recommended Custom Format scores
+export const CF_SCORES = {
+  // Unwanted (use negative scores)
+  "BR-DISK": -10000,
+  LQ: -10000,
+  "LQ (Release Title)": -10000,
+  "3D": -10000,
+  x265: -10000, // Only for HD, not UHD
+  Extras: -10000,
+
+  // Preferred (positive scores)
+  "Repack/Proper": 5,
+  Repack2: 6,
+
+  // HDR Formats
+  "DV HDR10Plus": 1600,
+  "DV HDR10": 1500,
+  DV: 1400,
+  "DV HLG": 1300,
+  "DV SDR": 1200,
+  HDR10Plus: 700,
+  HDR10: 600,
+  HDR: 500,
+  "HDR (undefined)": 400,
+  PQ: 300,
+  HLG: 200,
+
+  // Audio Formats
+  "TrueHD Atmos": 5000,
+  "DTS X": 4500,
+  TrueHD: 4000,
+  "DTS-HD MA": 3500,
+  FLAC: 3000,
+  PCM: 2500,
+  "DTS-HD HRA": 2000,
+  "DD+ Atmos": 1500,
+  "DD+": 1000,
+  "DTS-ES": 800,
+  DTS: 600,
+  AAC: 400,
+  DD: 300,
+
+  // Streaming Services
+  AMZN: 0,
+  ATVP: 100,
+  DSNP: 100,
+  HBO: 0,
+  HMAX: 0,
+  Hulu: 0,
+  MA: 0,
+  NF: 0,
+  PCOK: 0,
+  PMTP: 0,
+
+  // Movie Versions
+  "IMAX Enhanced": 800,
+  IMAX: 700,
+  Hybrid: 100,
+  "Criterion Collection": 100,
+  "Special Edition": 50,
+  "Theatrical Cut": 0,
+
+  // HQ Release Groups
+  "HQ-Remux": 1750,
+  "HQ-WEBDL": 1700,
+  HQ: 1600,
+}
+
+// Radarr Profile Presets
+export const RADARR_PRESETS: TRaSHProfilePreset[] = [
+  {
+    id: "hd-bluray-web",
+    name: "HD Bluray + WEB",
+    description: "High-Quality HD Encodes (Bluray-720p/1080p). Size: 6-15 GB",
+    app: "radarr",
+    cutoffQuality: "Bluray-1080p",
+    allowedQualities: ["Bluray-1080p", "Bluray-720p", "WEBDL-1080p", "WEBDL-720p", "WEBRip-1080p", "WEBRip-720p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "LQ (Release Title)": -10000,
+      "3D": -10000,
+      "x265 (HD)": -10000,
+      "Repack/Proper": 5,
+      "HQ-WEBDL": 1700,
+      HQ: 1600,
+    },
+  },
+  {
+    id: "uhd-bluray-web",
+    name: "UHD Bluray + WEB",
+    description: "High-Quality UHD Encodes (Bluray-2160p). Size: 20-60 GB",
+    app: "radarr",
+    cutoffQuality: "Bluray-2160p",
+    allowedQualities: ["Bluray-2160p", "WEBDL-2160p", "WEBRip-2160p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "LQ (Release Title)": -10000,
+      "DV HDR10Plus": 1600,
+      "DV HDR10": 1500,
+      DV: 1400,
+      HDR10Plus: 700,
+      HDR10: 600,
+      "Repack/Proper": 5,
+      "TrueHD Atmos": 5000,
+      "DTS X": 4500,
+      "HQ-WEBDL": 1700,
+    },
+  },
+  {
+    id: "remux-web-1080p",
+    name: "Remux + WEB 1080p",
+    description: "1080p Remuxes. Size: 20-40 GB",
+    app: "radarr",
+    cutoffQuality: "Remux-1080p",
+    allowedQualities: ["Remux-1080p", "WEBDL-1080p", "WEBRip-1080p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "x265 (HD)": -10000,
+      "HQ-Remux": 1750,
+      "Repack/Proper": 5,
+      "TrueHD Atmos": 5000,
+      "DTS X": 4500,
+      TrueHD: 4000,
+      "DTS-HD MA": 3500,
+    },
+  },
+  {
+    id: "remux-web-2160p",
+    name: "Remux + WEB 2160p",
+    description: "2160p Remuxes. Size: 40-100 GB",
+    app: "radarr",
+    cutoffQuality: "Remux-2160p",
+    allowedQualities: ["Remux-2160p", "WEBDL-2160p", "WEBRip-2160p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "DV HDR10Plus": 1600,
+      "DV HDR10": 1500,
+      DV: 1400,
+      HDR10Plus: 700,
+      HDR10: 600,
+      "HQ-Remux": 1750,
+      "Repack/Proper": 5,
+      "TrueHD Atmos": 5000,
+      "DTS X": 4500,
+    },
+  },
+]
+
+// Sonarr Profile Presets
+export const SONARR_PRESETS: TRaSHProfilePreset[] = [
+  {
+    id: "web-1080p",
+    name: "WEB-1080p",
+    description: "720p/1080p WEBDL. Balanced quality and size",
+    app: "sonarr",
+    cutoffQuality: "WEBDL-1080p",
+    allowedQualities: ["WEBDL-1080p", "WEBRip-1080p", "WEBDL-720p", "WEBRip-720p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "x265 (HD)": -10000,
+      "Repack/Proper": 5,
+      "HQ-WEBDL": 1700,
+      AMZN: 100,
+      ATVP: 100,
+      DSNP: 100,
+      NF: 100,
+    },
+  },
+  {
+    id: "web-2160p",
+    name: "WEB-2160p",
+    description: "2160p WEBDL with HDR. Premium quality",
+    app: "sonarr",
+    cutoffQuality: "WEBDL-2160p",
+    allowedQualities: ["WEBDL-2160p", "WEBRip-2160p"],
+    cfScores: {
+      "BR-DISK": -10000,
+      LQ: -10000,
+      "DV HDR10Plus": 1600,
+      "DV HDR10": 1500,
+      DV: 1400,
+      HDR10Plus: 700,
+      HDR10: 600,
+      "Repack/Proper": 5,
+      "HQ-WEBDL": 1700,
+      AMZN: 100,
+      ATVP: 100,
+      NF: 100,
+    },
+  },
+]
+
+// Get all presets for an app
+export function getPresetsForApp(app: "radarr" | "sonarr"): TRaSHProfilePreset[] {
+  if (app === "radarr") return RADARR_PRESETS
+  if (app === "sonarr") return SONARR_PRESETS
+  return []
+}
+
+// Get a specific preset by ID
+export function getPresetById(id: string): TRaSHProfilePreset | undefined {
+  return [...RADARR_PRESETS, ...SONARR_PRESETS].find((p) => p.id === id)
+}

package/src/ui/screens/AppConfigurator.ts

@@ -240,6 +240,28 @@ export class AppConfigurator extends BoxRenderable {
       this.updateDisplay()
     }
 
+    // Setup auth for *arr apps without root folders (e.g., Prowlarr)
+    if (this.globalPassword) {
+      const arrAppsNeedingAuth = ["prowlarr"]
+      for (const appId of arrAppsNeedingAuth) {
+        const appConfig = this.config.apps.find((a) => a.id === appId && a.enabled)
+        if (!appConfig) continue
+
+        const apiKey = this.extractApiKey(appId as AppId)
+        if (!apiKey) continue
+
+        const appDef = getApp(appId as AppId)
+        const port = appConfig.port || appDef?.defaultPort || 9696
+        const client = new ArrApiClient("localhost", port, apiKey)
+
+        try {
+          await client.updateHostConfig(this.globalUsername, this.globalPassword, this.overrideExisting)
+        } catch {
+          // Auth setup for these apps is best-effort
+        }
+      }
+    }
+
     // After root folders, prompt for download clients if needed
     if (this.hasQBittorrent || this.hasSABnzbd) {
       if (this.hasQBittorrent) {
@@ -291,8 +313,18 @@ export class AppConfigurator extends BoxRenderable {
       throw new Error("Already configured")
     }
 
-    // Add root folder
-    await client.addRootFolder(appDef.rootFolder.path)
+    // Add root folder - Lidarr requires profile IDs
+    if (appId === "lidarr") {
+      const metadataProfiles = await client.getMetadataProfiles()
+      const qualityProfiles = await client.getQualityProfiles()
+      await client.addRootFolder({
+        path: appDef.rootFolder.path,
+        defaultMetadataProfileId: metadataProfiles[0]?.id || 1,
+        defaultQualityProfileId: qualityProfiles[0]?.id || 1,
+      })
+    } else {
+      await client.addRootFolder(appDef.rootFolder.path)
+    }
 
     // Set up authentication if credentials provided
     if (this.globalPassword) {

package/src/ui/screens/MainMenu.ts

@@ -11,6 +11,8 @@ import { createPageLayout } from "../components/PageLayout"
 import { saveCompose } from "../../compose"
 import { ApiKeyViewer } from "./ApiKeyViewer"
 import { AppConfigurator } from "./AppConfigurator"
+import { TRaSHProfileSetup } from "./TRaSHProfileSetup"
+import { ProwlarrSetup } from "./ProwlarrSetup"
 
 export class MainMenu {
   private renderer: RenderContext
@@ -100,10 +102,18 @@ export class MainMenu {
           name: "⚙️  Configure Apps",
           description: "Set root folders and download clients via API",
         },
+        {
+          name: "🎯 TRaSH Guide Setup",
+          description: "Apply TRaSH quality profiles and custom formats",
+        },
         {
           name: "🔄 Regenerate Compose",
           description: "Rebuild docker-compose.yml",
         },
+        {
+          name: "🔗 Prowlarr Setup",
+          description: "Sync indexers to *arr apps, FlareSolverr",
+        },
         { name: "❌ Exit", description: "Close easiarr" },
       ],
     })
@@ -143,11 +153,33 @@ export class MainMenu {
           break
         }
         case 5: {
+          // TRaSH Profile Setup
+          this.menu.blur()
+          this.page.visible = false
+          const trashSetup = new TRaSHProfileSetup(this.renderer as CliRenderer, this.config, () => {
+            this.page.visible = true
+            this.menu.focus()
+          })
+          this.container.add(trashSetup)
+          break
+        }
+        case 6: {
           // Regenerate compose
           await saveCompose(this.config)
           break
         }
-        case 6:
+        case 7: {
+          // Prowlarr Setup
+          this.menu.blur()
+          this.page.visible = false
+          const prowlarrSetup = new ProwlarrSetup(this.renderer as CliRenderer, this.config, () => {
+            this.page.visible = true
+            this.menu.focus()
+          })
+          this.container.add(prowlarrSetup)
+          break
+        }
+        case 8:
           process.exit(0)
           break
       }