@muhammedaksam/easiarr 0.1.9 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "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

@@ -26,42 +26,16 @@ export interface DownloadClient extends DownloadClientConfig {
   id?: number
 }
 
-import type { AppId } from "../config/schema"
-
-// Get category name for an app
-function getCategoryForApp(appId: AppId): string {
-  switch (appId) {
-    case "radarr":
-      return "movies"
-    case "sonarr":
-      return "tv"
-    case "lidarr":
-      return "music"
-    case "readarr":
-      return "books"
-    case "whisparr":
-      return "adult"
-    default:
-      return "default"
-  }
+// Types for Remote Path Mapping API
+export interface RemotePathMapping {
+  id?: number
+  host: string
+  remotePath: string
+  localPath: string
 }
 
-// Get category field name for an app (different apps use different field names)
-function getCategoryFieldName(appId: AppId): string {
-  switch (appId) {
-    case "radarr":
-      return "movieCategory"
-    case "sonarr":
-    case "whisparr":
-      return "tvCategory"
-    case "lidarr":
-      return "musicCategory"
-    case "readarr":
-      return "bookCategory"
-    default:
-      return "category"
-  }
-}
+import type { AppId } from "../config/schema"
+import { getCategoryForApp, getCategoryFieldName } from "../utils/categories"
 
 // qBittorrent download client config
 export function createQBittorrentConfig(
@@ -86,6 +60,7 @@ export function createQBittorrentConfig(
       { name: "username", value: username },
       { name: "password", value: password },
       { name: categoryField, value: category },
+      { name: "savePath", value: "/data/torrents" },
       { name: "recentMoviePriority", value: 0 },
       { name: "olderMoviePriority", value: 0 },
       { name: "initialState", value: 0 },
@@ -111,6 +86,7 @@ export function createSABnzbdConfig(host: string, port: number, apiKey: string,
       { name: "port", value: port },
       { name: "apiKey", value: apiKey },
       { name: categoryField, value: category },
+      { name: "savePath", value: "/data/usenet" },
       { name: "recentMoviePriority", value: -100 },
       { name: "olderMoviePriority", value: -100 },
     ],
@@ -226,6 +202,22 @@ export class ArrApiClient {
       body: JSON.stringify(updatedConfig),
     })
   }
+
+  // Remote Path Mapping methods - for Docker path translation
+  async getRemotePathMappings(): Promise<RemotePathMapping[]> {
+    return this.request<RemotePathMapping[]>("/remotepathmapping")
+  }
+
+  async addRemotePathMapping(host: string, remotePath: string, localPath: string): Promise<RemotePathMapping> {
+    return this.request<RemotePathMapping>("/remotepathmapping", {
+      method: "POST",
+      body: JSON.stringify({ host, remotePath, localPath }),
+    })
+  }
+
+  async deleteRemotePathMapping(id: number): Promise<void> {
+    await this.request(`/remotepathmapping/${id}`, { method: "DELETE" })
+  }
 }
 
 // Types for Host Config API

package/src/api/qbittorrent-api.ts

@@ -0,0 +1,198 @@
+/**
+ * qBittorrent WebAPI Client
+ * Configures qBittorrent settings via API
+ * API docs: https://github.com/qbittorrent/qBittorrent/wiki/WebUI-API-(qBittorrent-4.1)
+ */
+
+export interface QBittorrentPreferences {
+  save_path?: string
+  temp_path_enabled?: boolean
+  temp_path?: string
+  auto_tmm_enabled?: boolean
+  category_changed_tmm_enabled?: boolean
+  save_path_changed_tmm_enabled?: boolean
+}
+
+export interface QBittorrentCategory {
+  name: string
+  savePath: string
+}
+
+export class QBittorrentClient {
+  private baseUrl: string
+  private username: string
+  private password: string
+  private cookie: string | null = null
+
+  constructor(host: string, port: number, username: string, password: string) {
+    this.baseUrl = `http://${host}:${port}`
+    this.username = username
+    this.password = password
+  }
+
+  /**
+   * Authenticate with qBittorrent WebUI
+   * POST /api/v2/auth/login
+   */
+  async login(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v2/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: `username=${encodeURIComponent(this.username)}&password=${encodeURIComponent(this.password)}`,
+      })
+
+      if (!response.ok) return false
+
+      // Extract SID cookie from response
+      const setCookie = response.headers.get("set-cookie")
+      if (setCookie) {
+        const match = setCookie.match(/SID=([^;]+)/)
+        if (match) {
+          this.cookie = `SID=${match[1]}`
+          return true
+        }
+      }
+
+      // Check response text for "Ok."
+      const text = await response.text()
+      return text === "Ok."
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if connected to qBittorrent
+   */
+  async isConnected(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v2/app/version`, {
+        headers: this.cookie ? { Cookie: this.cookie } : {},
+      })
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get current preferences
+   * GET /api/v2/app/preferences
+   */
+  async getPreferences(): Promise<QBittorrentPreferences> {
+    const response = await fetch(`${this.baseUrl}/api/v2/app/preferences`, {
+      headers: this.cookie ? { Cookie: this.cookie } : {},
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to get preferences: ${response.status}`)
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Set preferences
+   * POST /api/v2/app/setPreferences
+   */
+  async setPreferences(prefs: QBittorrentPreferences): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/app/setPreferences`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `json=${encodeURIComponent(JSON.stringify(prefs))}`,
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to set preferences: ${response.status}`)
+    }
+  }
+
+  /**
+   * Get all categories
+   * GET /api/v2/torrents/categories
+   */
+  async getCategories(): Promise<Record<string, { name: string; savePath: string }>> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/categories`, {
+      headers: this.cookie ? { Cookie: this.cookie } : {},
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to get categories: ${response.status}`)
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Create a category
+   * POST /api/v2/torrents/createCategory
+   */
+  async createCategory(name: string, savePath: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/createCategory`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `category=${encodeURIComponent(name)}&savePath=${encodeURIComponent(savePath)}`,
+    })
+
+    // 409 means category already exists - that's OK
+    if (!response.ok && response.status !== 409) {
+      throw new Error(`Failed to create category: ${response.status}`)
+    }
+  }
+
+  /**
+   * Edit a category's save path
+   * POST /api/v2/torrents/editCategory
+   */
+  async editCategory(name: string, savePath: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/editCategory`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `category=${encodeURIComponent(name)}&savePath=${encodeURIComponent(savePath)}`,
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to edit category: ${response.status}`)
+    }
+  }
+
+  /**
+   * Configure qBittorrent for TRaSH Guide compliance
+   * Sets proper save paths and creates categories based on enabled apps
+   * @param categories - Array of {name, savePath} for each enabled *arr app
+   */
+  async configureTRaSHCompliant(categories: QBittorrentCategory[] = []): Promise<void> {
+    // 1. Set global preferences
+    await this.setPreferences({
+      save_path: "/data/torrents",
+      temp_path_enabled: false,
+      auto_tmm_enabled: true,
+      category_changed_tmm_enabled: true,
+      save_path_changed_tmm_enabled: true,
+    })
+
+    // 2. Create categories for each enabled media type
+    for (const cat of categories) {
+      try {
+        await this.createCategory(cat.name, cat.savePath)
+      } catch {
+        // Try to update existing category
+        try {
+          await this.editCategory(cat.name, cat.savePath)
+        } catch {
+          // Ignore - category might not exist or be locked
+        }
+      }
+    }
+  }
+}

package/src/apps/registry.ts

@@ -246,7 +246,8 @@ export const APPS: Record<AppId, AppDefinition> = {
     image: "lscr.io/linuxserver/qbittorrent:latest",
     puid: 13007,
     pgid: 13000,
-    volumes: (root) => [`${root}/config/qbittorrent:/config`, `${root}/data/torrents:/data/torrents`],
+    // TRaSH: Mount full /data for consistent paths with *arr apps (enables hardlinks)
+    volumes: (root) => [`${root}/config/qbittorrent:/config`, `${root}/data:/data`],
     environment: { WEBUI_PORT: "8080" },
     trashGuide: "docs/Downloaders/qBittorrent/",
   },
@@ -260,7 +261,8 @@ export const APPS: Record<AppId, AppDefinition> = {
     image: "lscr.io/linuxserver/sabnzbd:latest",
     puid: 13011,
     pgid: 13000,
-    volumes: (root) => [`${root}/config/sabnzbd:/config`, `${root}/data/usenet:/data/usenet`],
+    // TRaSH: Mount full /data for consistent paths with *arr apps (enables hardlinks)
+    volumes: (root) => [`${root}/config/sabnzbd:/config`, `${root}/data:/data`],
 
     trashGuide: "docs/Downloaders/SABnzbd/",
     apiKeyMeta: {

package/src/compose/generator.ts

@@ -3,12 +3,12 @@
  * Generates docker-compose.yml from Easiarr configuration
  */
 
-import { writeFile, readFile } from "node:fs/promises"
-import { existsSync } from "node:fs"
+import { writeFile } from "node:fs/promises"
 import type { EasiarrConfig, AppConfig, TraefikConfig, AppId } from "../config/schema"
 import { getComposePath } from "../config/manager"
 import { getApp } from "../apps/registry"
 import { generateServiceYaml } from "./templates"
+import { updateEnv } from "../utils/env"
 
 export interface ComposeService {
   image: string
@@ -205,30 +205,12 @@ export async function saveCompose(config: EasiarrConfig): Promise<string> {
 }
 
 async function updateEnvFile(config: EasiarrConfig) {
-  const envPath = getComposePath().replace("docker-compose.yml", ".env")
-  let envContent = ""
-
-  // Read existing .env if present to preserve secrets
-  const currentEnv: Record<string, string> = {}
-  if (existsSync(envPath)) {
-    const content = await readFile(envPath, "utf-8")
-    content.split("\n").forEach((line) => {
-      const [key, ...val] = line.split("=")
-      if (key && val) currentEnv[key.trim()] = val.join("=").trim()
-    })
-  }
-
-  // Update/Set globals
-  currentEnv["ROOT_DIR"] = config.rootDir
-  currentEnv["TIMEZONE"] = config.timezone
-  currentEnv["PUID"] = config.uid.toString()
-  currentEnv["PGID"] = config.gid.toString()
-  currentEnv["UMASK"] = config.umask
-
-  // Reconstruct .env content
-  envContent = Object.entries(currentEnv)
-    .map(([k, v]) => `${k}=${v}`)
-    .join("\n")
-
-  await writeFile(envPath, envContent, "utf-8")
+  // Update .env with global configuration values
+  await updateEnv({
+    ROOT_DIR: config.rootDir,
+    TIMEZONE: config.timezone,
+    PUID: config.uid.toString(),
+    PGID: config.gid.toString(),
+    UMASK: config.umask,
+  })
 }

package/src/ui/screens/AdvancedSettings.ts

@@ -17,6 +17,7 @@ import { createPageLayout } from "../components/PageLayout"
 import { FileEditor } from "../components/FileEditor"
 import { readFile, writeFile } from "node:fs/promises"
 import { getConfigPath, getComposePath } from "../../config/manager"
+import { getEnvPath } from "../../utils/env"
 import { existsSync } from "node:fs"
 
 export class AdvancedSettings {
@@ -100,7 +101,7 @@ export class AdvancedSettings {
           })
           break
         case 1: {
-          const envPath = getComposePath().replace("docker-compose.yml", ".env")
+          const envPath = getEnvPath()
           await this.editFile(".env", envPath, async (content) => {
             await writeFile(envPath, content, "utf-8")
             this.renderMenu()

package/src/ui/screens/ApiKeyViewer.ts

@@ -1,13 +1,12 @@
 import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
 import { existsSync, readFileSync, writeFileSync } from "node:fs"
-import { writeFile, readFile } from "node:fs/promises"
 import { join } from "node:path"
 import { randomBytes } from "node:crypto"
 import { parse as parseYaml } from "yaml"
 import { createPageLayout } from "../components/PageLayout"
 import { EasiarrConfig, AppDefinition } from "../../config/schema"
 import { getApp } from "../../apps/registry"
-import { getComposePath } from "../../config/manager"
+import { updateEnv } from "../../utils/env"
 
 /** Generate a random 32-character hex API key */
 function generateApiKey(): string {
@@ -337,30 +336,13 @@ export class ApiKeyViewer extends BoxRenderable {
     if (foundKeys.length === 0) return
 
     try {
-      const envPath = getComposePath().replace("docker-compose.yml", ".env")
-
-      // Read existing .env if present
-      const currentEnv: Record<string, string> = {}
-      if (existsSync(envPath)) {
-        const content = await readFile(envPath, "utf-8")
-        content.split("\n").forEach((line) => {
-          const [key, ...val] = line.split("=")
-          if (key && val.length > 0) currentEnv[key.trim()] = val.join("=").trim()
-        })
-      }
-
-      // Add API keys with format API_KEY_SONARR, API_KEY_RADARR, etc.
+      // Build updates object with API keys
+      const updates: Record<string, string> = {}
       for (const k of foundKeys) {
-        const envKey = `API_KEY_${k.appId.toUpperCase()}`
-        currentEnv[envKey] = k.key
+        updates[`API_KEY_${k.appId.toUpperCase()}`] = k.key
       }
 
-      // Reconstruct .env content
-      const envContent = Object.entries(currentEnv)
-        .map(([k, v]) => `${k}=${v}`)
-        .join("\n")
-
-      await writeFile(envPath, envContent, "utf-8")
+      await updateEnv(updates)
 
       // Update status
       if (this.statusText) {

package/src/ui/screens/AppConfigurator.ts

@@ -11,14 +11,13 @@ import {
   InputRenderableEvents,
   KeyEvent,
 } from "@opentui/core"
-import { existsSync, readFileSync } from "node:fs"
-import { writeFile, readFile } from "node:fs/promises"
-import { join } from "node:path"
 import { createPageLayout } from "../components/PageLayout"
 import { EasiarrConfig, AppId } from "../../config/schema"
 import { getApp } from "../../apps/registry"
 import { ArrApiClient, createQBittorrentConfig, createSABnzbdConfig } from "../../api/arr-api"
-import { getComposePath } from "../../config/manager"
+import { QBittorrentClient } from "../../api/qbittorrent-api"
+import { getCategoriesForApps } from "../../utils/categories"
+import { readEnvSync, updateEnv } from "../../utils/env"
 
 interface ConfigResult {
   appId: AppId
@@ -83,29 +82,11 @@ export class AppConfigurator extends BoxRenderable {
   }
 
   private loadSavedCredentials() {
-    try {
-      const envPath = getComposePath().replace("docker-compose.yml", ".env")
-      if (!existsSync(envPath)) return
-
-      const content = readFileSync(envPath, "utf-8")
-      content.split("\n").forEach((line) => {
-        const [key, ...val] = line.split("=")
-        if (key && val.length > 0) {
-          const value = val.join("=").trim()
-          if (key.trim() === "GLOBAL_USERNAME") {
-            this.globalUsername = value
-          } else if (key.trim() === "GLOBAL_PASSWORD") {
-            this.globalPassword = value
-          } else if (key.trim() === "QBITTORRENT_PASSWORD") {
-            this.qbPass = value
-          } else if (key.trim() === "SABNZBD_API_KEY") {
-            this.sabApiKey = value
-          }
-        }
-      })
-    } catch {
-      // Ignore errors
-    }
+    const env = readEnvSync()
+    if (env.GLOBAL_USERNAME) this.globalUsername = env.GLOBAL_USERNAME
+    if (env.GLOBAL_PASSWORD) this.globalPassword = env.GLOBAL_PASSWORD
+    if (env.QBITTORRENT_PASSWORD) this.qbPass = env.QBITTORRENT_PASSWORD
+    if (env.SABNZBD_API_KEY) this.sabApiKey = env.SABNZBD_API_KEY
   }
 
   private renderCredentialsPrompt() {
@@ -114,7 +95,7 @@ export class AppConfigurator extends BoxRenderable {
     const { container, content } = createPageLayout(this.cliRenderer, {
       title: "Configure Apps",
       stepInfo: "Global Credentials",
-      footerHint: "Enter credentials for all *arr apps  Tab Next Field  Enter Continue  Esc Skip",
+      footerHint: "Tab Cycle Fields/Shortcuts  O Override  Enter Continue  Esc Skip",
     })
     this.pageContainer = container
     this.add(container)
@@ -174,13 +155,16 @@ export class AppConfigurator extends BoxRenderable {
         overrideText.content = `[O] Override existing: ${this.overrideExisting ? "Yes" : "No"}`
         overrideText.fg = this.overrideExisting ? "#50fa7b" : "#6272a4"
       } else if (key.name === "tab") {
-        // Toggle focus between inputs
+        // Cycle focus: username -> password -> no focus (shortcuts work) -> username
         if (focusedInput === userInput) {
           userInput.blur()
           passInput.focus()
           focusedInput = passInput
-        } else {
+        } else if (focusedInput === passInput) {
           passInput.blur()
+          focusedInput = null // No focus state - shortcuts available
+        } else {
+          // No input focused, go back to username
           userInput.focus()
           focusedInput = userInput
         }
@@ -214,32 +198,10 @@ export class AppConfigurator extends BoxRenderable {
 
   private async saveGlobalCredentialsToEnv() {
     try {
-      const envPath = getComposePath().replace("docker-compose.yml", ".env")
-
-      // Read existing .env if present
-      const currentEnv: Record<string, string> = {}
-      if (existsSync(envPath)) {
-        const content = await readFile(envPath, "utf-8")
-        content.split("\n").forEach((line) => {
-          const [key, ...val] = line.split("=")
-          if (key && val.length > 0) currentEnv[key.trim()] = val.join("=").trim()
-        })
-      }
-
-      // Add global credentials
-      if (this.globalUsername) {
-        currentEnv["GLOBAL_USERNAME"] = this.globalUsername
-      }
-      if (this.globalPassword) {
-        currentEnv["GLOBAL_PASSWORD"] = this.globalPassword
-      }
-
-      // Reconstruct .env content
-      const envContent = Object.entries(currentEnv)
-        .map(([k, v]) => `${k}=${v}`)
-        .join("\n")
-
-      await writeFile(envPath, envContent, "utf-8")
+      const updates: Record<string, string> = {}
+      if (this.globalUsername) updates.GLOBAL_USERNAME = this.globalUsername
+      if (this.globalPassword) updates.GLOBAL_PASSWORD = this.globalPassword
+      await updateEnv(updates)
     } catch {
       // Ignore errors - not critical
     }
@@ -343,27 +305,17 @@ export class AppConfigurator extends BoxRenderable {
   }
 
   private extractApiKey(appId: AppId): string | null {
-    const appDef = getApp(appId)
-    if (!appDef?.apiKeyMeta) return null
-
-    const volumes = appDef.volumes(this.config.rootDir)
-    if (volumes.length === 0) return null
-
-    const parts = volumes[0].split(":")
-    const hostPath = parts[0]
-    const configFilePath = join(hostPath, appDef.apiKeyMeta.configFile)
-
-    if (!existsSync(configFilePath)) return null
-
-    const content = readFileSync(configFilePath, "utf-8")
-
-    if (appDef.apiKeyMeta.parser === "regex") {
-      const regex = new RegExp(appDef.apiKeyMeta.selector)
-      const match = regex.exec(content)
-      return match?.[1] || null
-    }
+    // Use API keys from .env file (format: API_KEY_APPNAME)
+    const envKey = `API_KEY_${appId.toUpperCase()}`
+    return readEnvSync()[envKey] ?? null
+  }
 
-    return null
+  /**
+   * Get qBittorrent categories based on enabled *arr apps
+   */
+  private getEnabledCategories(): { name: string; savePath: string }[] {
+    const enabledAppIds = this.config.apps.filter((a) => a.enabled).map((a) => a.id)
+    return getCategoriesForApps(enabledAppIds)
   }
 
   private renderConfigProgress() {
@@ -543,6 +495,22 @@ export class AppConfigurator extends BoxRenderable {
   }
 
   private async addDownloadClients(type: "qbittorrent" | "sabnzbd") {
+    // Configure qBittorrent settings via its API first
+    if (type === "qbittorrent") {
+      try {
+        const qbClient = new QBittorrentClient(this.qbHost, this.qbPort, this.qbUser, this.qbPass)
+        const loggedIn = await qbClient.login()
+        if (loggedIn) {
+          // Generate categories from enabled *arr apps that use download clients
+          const categories = this.getEnabledCategories()
+          // Configure TRaSH-compliant settings: save_path, auto_tmm, categories
+          await qbClient.configureTRaSHCompliant(categories)
+        }
+      } catch {
+        // Ignore qBittorrent config errors - may not be ready or have different auth
+      }
+    }
+
     // Add download client to all *arr apps
     const servarrApps = this.config.apps.filter((a) => {
       const def = getApp(a.id)
@@ -587,31 +555,13 @@ export class AppConfigurator extends BoxRenderable {
 
   private async saveCredentialsToEnv(type: "qbittorrent" | "sabnzbd") {
     try {
-      const envPath = getComposePath().replace("docker-compose.yml", ".env")
-
-      // Read existing .env if present
-      const currentEnv: Record<string, string> = {}
-      if (existsSync(envPath)) {
-        const content = await readFile(envPath, "utf-8")
-        content.split("\n").forEach((line) => {
-          const [key, ...val] = line.split("=")
-          if (key && val.length > 0) currentEnv[key.trim()] = val.join("=").trim()
-        })
-      }
-
-      // Add credentials
+      const updates: Record<string, string> = {}
       if (type === "qbittorrent" && this.qbPass) {
-        currentEnv["QBITTORRENT_PASSWORD"] = this.qbPass
+        updates.QBITTORRENT_PASSWORD = this.qbPass
       } else if (type === "sabnzbd" && this.sabApiKey) {
-        currentEnv["SABNZBD_API_KEY"] = this.sabApiKey
+        updates.SABNZBD_API_KEY = this.sabApiKey
       }
-
-      // Reconstruct .env content
-      const envContent = Object.entries(currentEnv)
-        .map(([k, v]) => `${k}=${v}`)
-        .join("\n")
-
-      await writeFile(envPath, envContent, "utf-8")
+      await updateEnv(updates)
     } catch {
       // Ignore errors - not critical
     }

package/src/ui/screens/SecretsEditor.ts

@@ -10,10 +10,9 @@ import {
 } from "@opentui/core"
 import { EasiarrConfig, AppSecret } from "../../config/schema"
 import { getApp } from "../../apps/registry"
-import { getComposePath } from "../../config/manager"
-import { readFile, writeFile, mkdir } from "node:fs/promises"
+import { readEnv, updateEnv, getEnvPath } from "../../utils/env"
+import { mkdir } from "node:fs/promises"
 import { dirname } from "node:path"
-import { existsSync } from "node:fs"
 
 export interface SecretsEditorOptions extends BoxOptions {
   config: EasiarrConfig
@@ -177,65 +176,25 @@ export class SecretsEditor extends BoxRenderable {
   }
 
   private async loadEnv() {
-    const envPath = getComposePath().replace("docker-compose.yml", ".env")
-    if (existsSync(envPath)) {
-      try {
-        const content = await readFile(envPath, "utf-8")
-        content.split("\n").forEach((line) => {
-          const parts = line.split("=")
-          if (parts.length >= 2) {
-            const key = parts[0].trim()
-            const value = parts.slice(1).join("=").trim()
-            // Remove potential quotes
-            this.envValues[key] = value.replace(/^["'](.*?)["']$/, "$1")
-          }
-        })
-      } catch (e) {
-        console.error("Failed to read .env", e)
-      }
-    }
+    this.envValues = await readEnv()
   }
 
   private async save() {
-    const envPath = getComposePath().replace("docker-compose.yml", ".env")
-
-    // Read existing .env to preserve other values
-    const currentEnv: Record<string, string> = {}
-    if (existsSync(envPath)) {
-      try {
-        const content = await readFile(envPath, "utf-8")
-        content.split("\n").forEach((line) => {
-          const [key, ...val] = line.split("=")
-          if (key && val.length > 0) {
-            currentEnv[key.trim()] = val
-              .join("=")
-              .trim()
-              .replace(/^["'](.*?)["']$/, "$1")
-          }
-        })
-      } catch {
-        // Ignore read errors
-      }
-    }
-
-    // Update with new values from inputs
+    // Collect values from inputs
+    const updates: Record<string, string> = {}
     this.inputs.forEach((input, key) => {
-      currentEnv[key] = input.value
+      updates[key] = input.value
     })
 
     // Ensure directory exists
     try {
-      await mkdir(dirname(envPath), { recursive: true })
+      await mkdir(dirname(getEnvPath()), { recursive: true })
     } catch {
       // Ignore if exists
     }
 
-    // Write back
-    const envContent = Object.entries(currentEnv)
-      .map(([k, v]) => `${k}=${v}`)
-      .join("\n")
-
-    await writeFile(envPath, envContent, "utf-8")
+    // Update .env file
+    await updateEnv(updates)
 
     this.onSave()
   }

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/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]
+}