@muhammedaksam/easiarr 0.1.10 → 0.3.0

package/src/ui/screens/TRaSHProfileSetup.ts

@@ -0,0 +1,371 @@
+/**
+ * TRaSH Profile Setup Screen
+ * Allows users to configure TRaSH-recommended quality profiles and custom formats
+ */
+
+import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
+import { createPageLayout } from "../components/PageLayout"
+import { EasiarrConfig, AppId } from "../../config/schema"
+import { getApp } from "../../apps/registry"
+import { QualityProfileClient } from "../../api/quality-profile-api"
+import { CustomFormatClient, getCFNamesForCategories } from "../../api/custom-format-api"
+import { getPresetsForApp, TRaSHProfilePreset } from "../../data/trash-profiles"
+import { readEnvSync } from "../../utils/env"
+import { debugLog } from "../../utils/debug"
+
+interface SetupResult {
+  appId: AppId
+  appName: string
+  profile: string
+  cfCount: number
+  status: "pending" | "configuring" | "success" | "error"
+  message?: string
+}
+
+type Step = "select-apps" | "select-profiles" | "importing" | "done"
+
+export class TRaSHProfileSetup extends BoxRenderable {
+  private config: EasiarrConfig
+  private cliRenderer: CliRenderer
+  private onBack: () => void
+  private keyHandler!: (key: KeyEvent) => void
+  private results: SetupResult[] = []
+  private currentStep: Step = "select-apps"
+  private contentBox!: BoxRenderable
+  private pageContainer!: BoxRenderable
+
+  // Selected apps and profiles
+  private selectedApps: Map<AppId, boolean> = new Map()
+  private selectedProfiles: Map<AppId, string> = new Map()
+  private currentIndex = 0
+  private availableApps: AppId[] = []
+
+  constructor(cliRenderer: CliRenderer, config: EasiarrConfig, onBack: () => void) {
+    const { container: pageContainer, content: contentBox } = createPageLayout(cliRenderer, {
+      title: "TRaSH Guide Setup",
+      stepInfo: "Configure quality profiles and custom formats",
+      footerHint: "↑↓ Navigate  Space Select  Enter Confirm  Esc Back",
+    })
+    super(cliRenderer, { width: "100%", height: "100%" })
+    this.add(pageContainer)
+
+    this.config = config
+    this.cliRenderer = cliRenderer
+    this.onBack = onBack
+    this.contentBox = contentBox
+    this.pageContainer = pageContainer
+
+    // Get enabled *arr apps that support quality profiles
+    this.availableApps = config.apps.filter((a) => a.enabled && ["radarr", "sonarr"].includes(a.id)).map((a) => a.id)
+
+    // Initialize selections
+    this.availableApps.forEach((id) => {
+      this.selectedApps.set(id, true)
+      const presets = getPresetsForApp(id as "radarr" | "sonarr")
+      if (presets.length > 0) {
+        this.selectedProfiles.set(id, presets[0].id)
+      }
+    })
+
+    this.initKeyHandler()
+    this.refreshContent()
+  }
+
+  private initKeyHandler(): void {
+    this.keyHandler = (key: KeyEvent) => {
+      debugLog(
+        "TRaSH",
+        `Key pressed: name=${key.name}, ctrl=${key.ctrl}, step=${this.currentStep}, index=${this.currentIndex}`
+      )
+
+      if (key.name === "escape" || (key.name === "c" && key.ctrl)) {
+        this.cleanup()
+        return
+      }
+
+      switch (this.currentStep) {
+        case "select-apps":
+          this.handleSelectAppsKeys(key)
+          break
+        case "select-profiles":
+          this.handleSelectProfilesKeys(key)
+          break
+        case "done":
+          if (key.name === "return" || key.name === "escape") {
+            this.cleanup()
+          }
+          break
+      }
+    }
+    this.cliRenderer.keyInput.on("keypress", this.keyHandler)
+    debugLog("TRaSH", `Key handler registered, availableApps=${this.availableApps.join(",")}`)
+  }
+
+  private handleSelectAppsKeys(key: KeyEvent): void {
+    const apps = this.availableApps
+
+    if (key.name === "up" && this.currentIndex > 0) {
+      debugLog("TRaSH", `Moving up from ${this.currentIndex} to ${this.currentIndex - 1}`)
+      this.currentIndex--
+      this.refreshContent()
+    } else if (key.name === "down" && this.currentIndex < apps.length - 1) {
+      debugLog("TRaSH", `Moving down from ${this.currentIndex} to ${this.currentIndex + 1}, apps.length=${apps.length}`)
+      this.currentIndex++
+      this.refreshContent()
+    } else if (key.name === "space") {
+      const app = apps[this.currentIndex]
+      this.selectedApps.set(app, !this.selectedApps.get(app))
+      this.refreshContent()
+    } else if (key.name === "return") {
+      const hasSelected = Array.from(this.selectedApps.values()).some((v) => v)
+      if (hasSelected) {
+        this.currentStep = "select-profiles"
+        this.currentIndex = 0
+        this.refreshContent()
+      }
+    }
+  }
+
+  private handleSelectProfilesKeys(key: KeyEvent): void {
+    const selectedAppIds = this.availableApps.filter((id) => this.selectedApps.get(id))
+    const app = selectedAppIds[this.currentIndex]
+    const presets = getPresetsForApp(app as "radarr" | "sonarr")
+
+    if (key.name === "up") {
+      const current = this.selectedProfiles.get(app)
+      const idx = presets.findIndex((p) => p.id === current)
+      if (idx > 0) {
+        this.selectedProfiles.set(app, presets[idx - 1].id)
+        this.refreshContent()
+      }
+    } else if (key.name === "down") {
+      const current = this.selectedProfiles.get(app)
+      const idx = presets.findIndex((p) => p.id === current)
+      if (idx < presets.length - 1) {
+        this.selectedProfiles.set(app, presets[idx + 1].id)
+        this.refreshContent()
+      }
+    } else if (key.name === "tab" || key.name === "right") {
+      if (this.currentIndex < selectedAppIds.length - 1) {
+        this.currentIndex++
+        this.refreshContent()
+      }
+    } else if (key.name === "left" && this.currentIndex > 0) {
+      this.currentIndex--
+      this.refreshContent()
+    } else if (key.name === "return") {
+      this.startImport()
+    } else if (key.name === "backspace" || key.name === "b") {
+      this.currentStep = "select-apps"
+      this.currentIndex = 0
+      this.refreshContent()
+    }
+  }
+
+  private async startImport(): Promise<void> {
+    this.currentStep = "importing"
+    this.results = []
+
+    const selectedAppIds = this.availableApps.filter((id) => this.selectedApps.get(id))
+
+    for (const appId of selectedAppIds) {
+      const appDef = getApp(appId)
+      const profileId = this.selectedProfiles.get(appId)
+      const preset = getPresetsForApp(appId as "radarr" | "sonarr").find((p) => p.id === profileId)
+
+      if (!appDef || !preset) continue
+
+      this.results.push({
+        appId,
+        appName: appDef.name,
+        profile: preset.name,
+        cfCount: 0,
+        status: "configuring",
+      })
+      this.refreshContent()
+
+      try {
+        await this.configureApp(appId, preset)
+        const result = this.results.find((r) => r.appId === appId)
+        if (result) {
+          result.status = "success"
+          result.cfCount = Object.keys(preset.cfScores).length
+        }
+      } catch (error) {
+        const result = this.results.find((r) => r.appId === appId)
+        if (result) {
+          result.status = "error"
+          result.message = error instanceof Error ? error.message : "Unknown error"
+        }
+      }
+      this.refreshContent()
+    }
+
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
+  private async configureApp(appId: AppId, preset: TRaSHProfilePreset): Promise<void> {
+    const appDef = getApp(appId)
+    if (!appDef) throw new Error("App not found")
+
+    const env = readEnvSync()
+    const apiKey = env[`API_KEY_${appId.toUpperCase()}`]
+    if (!apiKey) throw new Error("API key not found - run Extract API Keys first")
+
+    const port = this.config.apps.find((a) => a.id === appId)?.port || appDef.defaultPort
+    const qpClient = new QualityProfileClient("localhost", port, apiKey)
+    const cfClient = new CustomFormatClient("localhost", port, apiKey)
+
+    // Import Custom Formats first
+    const cfCategories = ["unwanted", "misc"]
+    if (preset.id.includes("uhd") || preset.id.includes("2160")) {
+      cfCategories.push("hdr")
+    }
+    if (preset.id.includes("remux")) {
+      cfCategories.push("audio")
+    }
+
+    const cfNames = getCFNamesForCategories(appId as "radarr" | "sonarr", cfCategories)
+    const { cfs } = await CustomFormatClient.fetchTRaSHCustomFormats(appId as "radarr" | "sonarr", cfNames)
+    await cfClient.importCustomFormats(cfs)
+
+    // Create quality profile
+    await qpClient.createTRaSHProfile(preset.name, preset.cutoffQuality, preset.allowedQualities, preset.cfScores)
+  }
+
+  private refreshContent(): void {
+    // Clear content
+    this.contentBox.getChildren().forEach((child) => child.destroy())
+
+    switch (this.currentStep) {
+      case "select-apps":
+        this.renderSelectApps()
+        break
+      case "select-profiles":
+        this.renderSelectProfiles()
+        break
+      case "importing":
+      case "done":
+        this.renderResults()
+        break
+    }
+  }
+
+  private renderSelectApps(): void {
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "Select apps to configure with TRaSH profiles:\n(Space to toggle, Enter to continue)\n\n",
+        fg: "#aaaaaa",
+      })
+    )
+
+    this.availableApps.forEach((appId, idx) => {
+      const app = getApp(appId)
+      const selected = this.selectedApps.get(appId)
+      const pointer = idx === this.currentIndex ? "→ " : "  "
+      const check = selected ? "[✓]" : "[ ]"
+      const fg = idx === this.currentIndex ? "#50fa7b" : selected ? "#8be9fd" : "#6272a4"
+
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: `${pointer}${check} ${app?.name || appId}\n`,
+          fg,
+        })
+      )
+    })
+  }
+
+  private renderSelectProfiles(): void {
+    const selectedAppIds = this.availableApps.filter((id) => this.selectedApps.get(id))
+
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "Select quality profile for each app:\n(↑↓ change profile, Tab next app, Enter apply)\n\n",
+        fg: "#aaaaaa",
+      })
+    )
+
+    selectedAppIds.forEach((appId, appIdx) => {
+      const app = getApp(appId)
+      const presets = getPresetsForApp(appId as "radarr" | "sonarr")
+      const selectedPresetId = this.selectedProfiles.get(appId)
+      const isCurrent = appIdx === this.currentIndex
+
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: `${isCurrent ? "→ " : "  "}${app?.name}:\n`,
+          fg: isCurrent ? "#50fa7b" : "#8be9fd",
+        })
+      )
+
+      presets.forEach((preset) => {
+        const isSelected = preset.id === selectedPresetId
+        const bullet = isSelected ? "●" : "○"
+        this.contentBox.add(
+          new TextRenderable(this.cliRenderer, {
+            content: `    ${bullet} ${preset.name}\n`,
+            fg: isSelected ? "#f1fa8c" : "#6272a4",
+          })
+        )
+      })
+    })
+  }
+
+  private renderResults(): void {
+    const headerText = this.currentStep === "done" ? "✓ Configuration Complete!\n\n" : "Configuring...\n\n"
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: headerText,
+        fg: this.currentStep === "done" ? "#50fa7b" : "#f1fa8c",
+      })
+    )
+
+    for (const result of this.results) {
+      let status = ""
+      let fg = "#aaaaaa"
+      switch (result.status) {
+        case "pending":
+          status = "⏳"
+          break
+        case "configuring":
+          status = "🔄"
+          fg = "#f1fa8c"
+          break
+        case "success":
+          status = "✓"
+          fg = "#50fa7b"
+          break
+        case "error":
+          status = "✗"
+          fg = "#ff5555"
+          break
+      }
+
+      let content = `${status} ${result.appName}: ${result.profile}`
+      if (result.status === "success") {
+        content += ` (${result.cfCount} CF scores)`
+      }
+      if (result.message) {
+        content += ` - ${result.message}`
+      }
+
+      this.contentBox.add(new TextRenderable(this.cliRenderer, { content: content + "\n", fg }))
+    }
+
+    if (this.currentStep === "done") {
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: "\nPress Enter or Esc to continue...",
+          fg: "#6272a4",
+        })
+      )
+    }
+  }
+
+  private cleanup(): void {
+    this.cliRenderer.keyInput.off("keypress", this.keyHandler)
+    this.destroy()
+    this.onBack()
+  }
+}

package/src/utils/categories.ts

@@ -0,0 +1,59 @@
+/**
+ * Download Category Utilities
+ * Shared category mappings for *arr apps and download clients
+ */
+
+import type { AppId } from "../config/schema"
+
+// Category info for each *arr app
+export interface CategoryInfo {
+  name: string
+  savePath: string
+  fieldName: string // Field name used in *arr download client config
+}
+
+// Master mapping of app IDs to their download categories
+const CATEGORY_MAP: Partial<Record<AppId, CategoryInfo>> = {
+  radarr: { name: "movies", savePath: "/data/torrents/movies", fieldName: "movieCategory" },
+  sonarr: { name: "tv", savePath: "/data/torrents/tv", fieldName: "tvCategory" },
+  lidarr: { name: "music", savePath: "/data/torrents/music", fieldName: "musicCategory" },
+  readarr: { name: "books", savePath: "/data/torrents/books", fieldName: "bookCategory" },
+  whisparr: { name: "adult", savePath: "/data/torrents/adult", fieldName: "tvCategory" },
+  mylar3: { name: "comics", savePath: "/data/torrents/comics", fieldName: "category" },
+}
+
+/**
+ * Get category name for an app (e.g., "movies" for radarr)
+ */
+export function getCategoryForApp(appId: AppId): string {
+  return CATEGORY_MAP[appId]?.name ?? "default"
+}
+
+/**
+ * Get the field name used in *arr download client config for category
+ * (e.g., "movieCategory" for radarr, "tvCategory" for sonarr)
+ */
+export function getCategoryFieldName(appId: AppId): string {
+  return CATEGORY_MAP[appId]?.fieldName ?? "category"
+}
+
+/**
+ * Get the save path for an app's downloads (e.g., "/data/torrents/movies" for radarr)
+ */
+export function getCategorySavePath(appId: AppId): string {
+  return CATEGORY_MAP[appId]?.savePath ?? "/data/torrents"
+}
+
+/**
+ * Get full category info for an app
+ */
+export function getCategoryInfo(appId: AppId): CategoryInfo | undefined {
+  return CATEGORY_MAP[appId]
+}
+
+/**
+ * Get all category infos for a list of enabled app IDs
+ */
+export function getCategoriesForApps(appIds: AppId[]): CategoryInfo[] {
+  return appIds.map((id) => CATEGORY_MAP[id]).filter((info): info is CategoryInfo => info !== undefined)
+}

package/src/utils/debug.ts

@@ -0,0 +1,27 @@
+/**
+ * Debug logging utility for Easiarr
+ *
+ * Only logs when EASIARR_DEBUG environment variable is set.
+ * Usage: EASIARR_DEBUG=1 bun run dev
+ */
+
+import { appendFileSync } from "fs"
+import { join } from "path"
+
+const DEBUG_ENABLED = process.env.EASIARR_DEBUG === "1" || process.env.EASIARR_DEBUG === "true"
+const logFile = join(import.meta.dir, "..", "..", "debug.log")
+
+/**
+ * Log a debug message to debug.log file if EASIARR_DEBUG is enabled
+ */
+export function debugLog(category: string, message: string): void {
+  if (!DEBUG_ENABLED) return
+
+  const timestamp = new Date().toISOString()
+  const line = `[${timestamp}] [${category}] ${message}\n`
+  try {
+    appendFileSync(logFile, line)
+  } catch {
+    // Ignore logging errors
+  }
+}

package/src/utils/env.ts

@@ -0,0 +1,98 @@
+/**
+ * Environment File Utilities
+ * Shared functions for reading/writing .env files
+ */
+
+import { existsSync, readFileSync } from "node:fs"
+import { writeFile, readFile } from "node:fs/promises"
+import { getComposePath } from "../config/manager"
+
+/**
+ * Get the path to the .env file
+ */
+export function getEnvPath(): string {
+  return getComposePath().replace("docker-compose.yml", ".env")
+}
+
+/**
+ * Parse an .env file into a key-value object
+ * Preserves existing values and handles multi-part values (e.g., with = in them)
+ */
+export function parseEnvFile(content: string): Record<string, string> {
+  const env: Record<string, string> = {}
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith("#")) continue
+
+    const [key, ...val] = trimmed.split("=")
+    if (key && val.length > 0) {
+      env[key.trim()] = val.join("=").trim()
+    }
+  }
+
+  return env
+}
+
+/**
+ * Serialize an env object to .env file format
+ */
+export function serializeEnv(env: Record<string, string>): string {
+  return Object.entries(env)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n")
+}
+
+/**
+ * Read the .env file and return parsed key-value object
+ * Returns empty object if file doesn't exist
+ */
+export function readEnvSync(): Record<string, string> {
+  const envPath = getEnvPath()
+  if (!existsSync(envPath)) return {}
+
+  try {
+    const content = readFileSync(envPath, "utf-8")
+    return parseEnvFile(content)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Read the .env file asynchronously
+ */
+export async function readEnv(): Promise<Record<string, string>> {
+  const envPath = getEnvPath()
+  if (!existsSync(envPath)) return {}
+
+  try {
+    const content = await readFile(envPath, "utf-8")
+    return parseEnvFile(content)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Write to .env file, merging with existing values
+ * Preserves existing keys not in the updates object
+ */
+export async function updateEnv(updates: Record<string, string>): Promise<void> {
+  const envPath = getEnvPath()
+  const current = await readEnv()
+
+  // Merge updates into current
+  const merged = { ...current, ...updates }
+
+  // Write back
+  const content = serializeEnv(merged)
+  await writeFile(envPath, content, "utf-8")
+}
+
+/**
+ * Get a specific value from .env
+ */
+export function getEnvValue(key: string): string | undefined {
+  return readEnvSync()[key]
+}