@muhammedaksam/easiarr 0.1.1 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "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/apps/registry.ts

@@ -94,6 +94,10 @@ export const APPS: Record<AppId, AppDefinition> = {
       path: "/data/media/books",
       apiVersion: "v1",
     },
+    arch: {
+      deprecated: ["arm64", "arm32"],
+      warning: "Readarr is deprecated - no ARM64 support (project abandoned by upstream)",
+    },
   },
 
   bazarr: {
@@ -109,9 +113,9 @@ export const APPS: Record<AppId, AppDefinition> = {
     dependsOn: ["sonarr", "radarr"],
     trashGuide: "docs/Bazarr/",
     apiKeyMeta: {
-      configFile: "config/config.ini",
-      parser: "regex",
-      selector: "apikey\\s*=\\s*(.+)",
+      configFile: "config/config.yaml",
+      parser: "yaml",
+      selector: "auth.apikey",
     },
   },
 
@@ -127,8 +131,15 @@ export const APPS: Record<AppId, AppDefinition> = {
     volumes: (root) => [`${root}/config/mylar3:/config`, `${root}/data:/data`],
     apiKeyMeta: {
       configFile: "mylar/config.ini",
-      parser: "regex",
-      selector: "api_key\\s*=\\s*(.+)",
+      parser: "ini",
+      section: "API",
+      selector: "api_key",
+      enabledKey: "api_enabled",
+      generateIfMissing: true,
+    },
+    rootFolder: {
+      path: "/data/media/comics",
+      apiVersion: "v1",
     },
   },
 
@@ -138,7 +149,7 @@ export const APPS: Record<AppId, AppDefinition> = {
     description: "Adult media collection manager",
     category: "servarr",
     defaultPort: 6969,
-    image: "hotio/whisparr:nightly",
+    image: "ghcr.io/hotio/whisparr:nightly",
     puid: 13015,
     pgid: 13000,
     volumes: (root) => [`${root}/config/whisparr:/config`, `${root}/data:/data`],
@@ -866,3 +877,32 @@ export function getAllApps(): AppDefinition[] {
 export function getAppIds(): AppId[] {
   return Object.keys(APPS) as AppId[]
 }
+
+import { getSystemArch, isAppCompatible, getArchWarning, isAppDeprecated } from "../util/arch"
+
+/**
+ * Get all apps compatible with the current system architecture
+ */
+export function getCompatibleApps(): AppDefinition[] {
+  const arch = getSystemArch()
+  return Object.values(APPS).filter((app) => isAppCompatible(app, arch))
+}
+
+/**
+ * Get apps that have warnings for the current architecture (deprecated but may work)
+ */
+export function getAppsWithArchWarnings(): { app: AppDefinition; warning: string }[] {
+  const arch = getSystemArch()
+  const result: { app: AppDefinition; warning: string }[] = []
+
+  for (const app of Object.values(APPS)) {
+    const warning = getArchWarning(app, arch)
+    if (warning) {
+      result.push({ app, warning })
+    }
+  }
+
+  return result
+}
+
+export { getSystemArch, isAppCompatible, getArchWarning, isAppDeprecated }

package/src/config/schema.ts

@@ -123,6 +123,17 @@ export type AppCategory =
   | "monitoring"
   | "infrastructure"
 
+export type Architecture = "x64" | "arm64" | "arm32"
+
+export interface ArchCompatibility {
+  /** Architectures with full support */
+  supported?: Architecture[]
+  /** Architectures with deprecated/broken support - will show warning */
+  deprecated?: Architecture[]
+  /** Warning message to show for deprecated architectures */
+  warning?: string
+}
+
 export interface AppDefinition {
   id: AppId
   name: string
@@ -141,6 +152,8 @@ export interface AppDefinition {
   cap_add?: string[]
   apiKeyMeta?: ApiKeyMeta
   rootFolder?: RootFolderMeta
+  /** Architecture compatibility info - omit if supports all */
+  arch?: ArchCompatibility
 }
 
 export interface RootFolderMeta {
@@ -151,12 +164,18 @@ export interface RootFolderMeta {
 export interface ApiKeyMeta {
   configFile: string // Relative to config volume root
   parser: ApiKeyParserType
-  selector: string // Regex group 1, or XML tag, or INI key, or JSON path
+  selector: string // Regex group 1, or XML tag, or INI key, JSON/YAML dot path
+  /** INI section name (for parser: "ini") */
+  section?: string
+  /** INI key that controls if API is enabled (for parser: "ini") */
+  enabledKey?: string
+  /** Generate API key if missing or None (for apps like Mylar3) */
+  generateIfMissing?: boolean
   description?: string
   transform?: (value: string) => string
 }
 
-export type ApiKeyParserType = "xml" | "ini" | "json" | "regex"
+export type ApiKeyParserType = "xml" | "ini" | "json" | "yaml" | "regex"
 
 export interface AppSecret {
   name: string

package/src/ui/components/ApplicationSelector.ts

@@ -11,7 +11,7 @@ import {
 } from "@opentui/core"
 import { AppId } from "../../config/schema"
 import { CATEGORY_ORDER } from "../../apps/categories"
-import { getAppsByCategory } from "../../apps"
+import { getAppsByCategory, getArchWarning } from "../../apps"
 
 export interface ApplicationSelectorOptions extends BoxOptions {
   selectedApps: Set<AppId>
@@ -139,10 +139,15 @@ export class ApplicationSelector extends BoxRenderable {
     const category = CATEGORY_ORDER[this.currentCategoryIndex]
     const apps = getAppsByCategory()[category.id] || []
 
-    const options = apps.map((app) => ({
-      name: `${this.selectedApps.has(app.id) ? "[✓]" : "[ ]"} ${app.name}`,
-      description: `Port ${app.defaultPort} - ${app.description}`,
-    }))
+    const options = apps.map((app) => {
+      const archWarning = getArchWarning(app)
+      const checkmark = this.selectedApps.has(app.id) ? "[✓]" : "[ ]"
+      const warnIcon = archWarning ? " ⚠️" : ""
+      return {
+        name: `${checkmark} ${app.name}${warnIcon}`,
+        description: archWarning ? `⚠️ ${archWarning}` : `Port ${app.defaultPort} - ${app.description}`,
+      }
+    })
 
     this.appList.options = options
   }
@@ -177,6 +182,17 @@ export class ApplicationSelector extends BoxRenderable {
     check(["overseerr", "jellyseerr"], "Multiple request managers")
     check(["prowlarr", "jackett"], "Multiple indexers")
 
+    // Architecture warnings for selected apps
+    const allApps = Object.values(getAppsByCategory()).flat()
+    for (const app of allApps) {
+      if (this.selectedApps.has(app.id)) {
+        const archWarn = getArchWarning(app)
+        if (archWarn) {
+          warnings.push(archWarn)
+        }
+      }
+    }
+
     return warnings
   }
 

package/src/ui/screens/ApiKeyViewer.ts

@@ -1,15 +1,112 @@
 import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
-import { existsSync, readFileSync } from "node:fs"
+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 } from "../../config/schema"
+import { EasiarrConfig, AppDefinition } from "../../config/schema"
 import { getApp } from "../../apps/registry"
 import { getComposePath } from "../../config/manager"
 
+/** Generate a random 32-character hex API key */
+function generateApiKey(): string {
+  return randomBytes(16).toString("hex")
+}
+
+/** Get nested value from object using dot notation */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  return path.split(".").reduce<unknown>((o, k) => (o as Record<string, unknown>)?.[k], obj)
+}
+
+/** Parse INI file and get value from section.key */
+function parseIniValue(content: string, section: string, key: string): string | null {
+  const lines = content.split("\n")
+  let inSection = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    // Check section header
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const sectionName = trimmed.slice(1, -1)
+      inSection = sectionName.toLowerCase() === section.toLowerCase()
+      continue
+    }
+
+    // Parse key=value in current section
+    if (inSection && trimmed.includes("=")) {
+      const [k, ...valueParts] = trimmed.split("=")
+      if (k.trim().toLowerCase() === key.toLowerCase()) {
+        let value = valueParts.join("=").trim()
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1)
+        }
+        return value
+      }
+    }
+  }
+  return null
+}
+
+/** Update INI file with new values for section */
+function updateIniValue(content: string, section: string, updates: Record<string, string>): string {
+  const lines = content.split("\n")
+  const result: string[] = []
+  let inSection = false
+  const updatedKeys = new Set<string>()
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    // Check section header
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      // Before leaving current section, add any missing keys
+      if (inSection) {
+        for (const [k, v] of Object.entries(updates)) {
+          if (!updatedKeys.has(k.toLowerCase())) {
+            result.push(`${k} = ${v}`)
+          }
+        }
+      }
+      const sectionName = trimmed.slice(1, -1)
+      inSection = sectionName.toLowerCase() === section.toLowerCase()
+      result.push(line)
+      continue
+    }
+
+    // Update key=value in current section
+    if (inSection && trimmed.includes("=")) {
+      const [k] = trimmed.split("=")
+      const keyName = k.trim()
+      const keyLower = keyName.toLowerCase()
+
+      let handled = false
+      for (const [updateKey, updateValue] of Object.entries(updates)) {
+        if (updateKey.toLowerCase() === keyLower) {
+          result.push(`${keyName} = ${updateValue}`)
+          updatedKeys.add(keyLower)
+          handled = true
+          break
+        }
+      }
+      if (!handled) {
+        result.push(line)
+      }
+    } else {
+      result.push(line)
+    }
+  }
+
+  return result.join("\n")
+}
+
+type KeyStatus = "found" | "missing" | "error" | "generated"
+
 export class ApiKeyViewer extends BoxRenderable {
   private config: EasiarrConfig
-  private keys: Array<{ appId: string; app: string; key: string; status: "found" | "missing" | "error" }> = []
+  private keys: Array<{ appId: string; app: string; key: string; status: KeyStatus }> = []
   private keyHandler!: (key: KeyEvent) => void
   private cliRenderer: CliRenderer
   private statusText: TextRenderable | null = null
@@ -19,8 +116,8 @@ export class ApiKeyViewer extends BoxRenderable {
       id: "api-key-viewer",
       width: "100%",
       height: "100%",
-      backgroundColor: "#111111", // Dark bg
-      zIndex: 200, // Above main menu
+      backgroundColor: "#111111",
+      zIndex: 200,
     })
     this.cliRenderer = renderer
     this.config = config
@@ -39,38 +136,17 @@ export class ApiKeyViewer extends BoxRenderable {
       if (!appDef || !appDef.apiKeyMeta) continue
 
       try {
-        // Resolve config path
-        // Volumes are: ["${root}/config/radarr:/config", ...]
-        // We assume index 0 is the config volume
         const volumes = appDef.volumes(this.config.rootDir)
         if (volumes.length === 0) continue
 
         const parts = volumes[0].split(":")
         const hostPath = parts[0]
-
         const configFilePath = join(hostPath, appDef.apiKeyMeta.configFile)
 
         if (existsSync(configFilePath)) {
           const content = readFileSync(configFilePath, "utf-8")
-
-          if (appDef.apiKeyMeta.parser === "regex") {
-            const regex = new RegExp(appDef.apiKeyMeta.selector)
-            const match = regex.exec(content)
-            if (match && match[1]) {
-              this.keys.push({ appId: appDef.id, app: appDef.name, key: match[1], status: "found" })
-            } else {
-              this.keys.push({ appId: appDef.id, app: appDef.name, key: "Not found in file", status: "error" })
-            }
-          } else if (appDef.apiKeyMeta.parser === "json") {
-            const json = JSON.parse(content)
-            // Support dot notation like "main.apiKey"
-            const value = appDef.apiKeyMeta.selector.split(".").reduce((obj, key) => obj?.[key], json)
-            if (value && typeof value === "string") {
-              this.keys.push({ appId: appDef.id, app: appDef.name, key: value, status: "found" })
-            } else {
-              this.keys.push({ appId: appDef.id, app: appDef.name, key: "Key not found in JSON", status: "error" })
-            }
-          }
+          const result = this.extractApiKey(appDef, content, configFilePath)
+          this.keys.push({ appId: appDef.id, app: appDef.name, ...result })
         } else {
           this.keys.push({
             appId: appDef.id,
@@ -79,14 +155,82 @@ export class ApiKeyViewer extends BoxRenderable {
             status: "missing",
           })
         }
-      } catch {
-        this.keys.push({ appId: appDef.id, app: appDef.name, key: "Error reading file", status: "error" })
+      } catch (e) {
+        this.keys.push({ appId: appDef.id, app: appDef.name, key: `Error: ${e}`, status: "error" })
+      }
+    }
+  }
+
+  private extractApiKey(
+    appDef: AppDefinition,
+    content: string,
+    configFilePath: string
+  ): { key: string; status: "found" | "error" | "generated" } {
+    const meta = appDef.apiKeyMeta!
+
+    switch (meta.parser) {
+      case "regex": {
+        const regex = new RegExp(meta.selector)
+        const match = regex.exec(content)
+        if (match && match[1]) {
+          return { key: match[1], status: "found" }
+        }
+        return { key: "Not found in file", status: "error" }
+      }
+
+      case "json": {
+        const json = JSON.parse(content)
+        const value = getNestedValue(json, meta.selector)
+        if (value && typeof value === "string") {
+          return { key: value, status: "found" }
+        }
+        return { key: "Key not found in JSON", status: "error" }
       }
+
+      case "yaml": {
+        const yaml = parseYaml(content) as Record<string, unknown>
+        const value = getNestedValue(yaml, meta.selector)
+        if (value && typeof value === "string") {
+          return { key: value, status: "found" }
+        }
+        return { key: "Key not found in YAML", status: "error" }
+      }
+
+      case "ini": {
+        const section = meta.section || "General"
+        const value = parseIniValue(content, section, meta.selector)
+
+        // Check if API is enabled and if we need to generate
+        if (meta.enabledKey) {
+          const enabled = parseIniValue(content, section, meta.enabledKey)
+          const isDisabled = !enabled || enabled.toLowerCase() === "false" || enabled === "0"
+          const needsGeneration = !value || value.toLowerCase() === "none" || value === ""
+
+          if (meta.generateIfMissing && (isDisabled || needsGeneration)) {
+            const newKey = generateApiKey()
+            const updates: Record<string, string> = { [meta.selector]: newKey }
+            if (meta.enabledKey) {
+              updates[meta.enabledKey] = "True"
+            }
+            const newContent = updateIniValue(content, section, updates)
+            writeFileSync(configFilePath, newContent, "utf-8")
+            return { key: newKey, status: "generated" }
+          }
+        }
+
+        if (value && value.toLowerCase() !== "none" && value !== "") {
+          return { key: value, status: "found" }
+        }
+        return { key: "API key not configured", status: "error" }
+      }
+
+      default:
+        return { key: `Unknown parser: ${meta.parser}`, status: "error" }
     }
   }
 
   private renderPage(onBack: () => void) {
-    const foundKeys = this.keys.filter((k) => k.status === "found")
+    const foundKeys = this.keys.filter((k) => k.status === "found" || k.status === "generated")
     const hasFoundKeys = foundKeys.length > 0
 
     const { container, content } = createPageLayout(this.cliRenderer, {
@@ -126,19 +270,28 @@ export class ApiKeyViewer extends BoxRenderable {
           marginBottom: 0,
         })
 
+        // Status color
+        let color = "#6272a4"
+        if (k.status === "found") color = "#50fa7b"
+        else if (k.status === "generated") color = "#8be9fd"
+        else if (k.status === "error") color = "#ff5555"
+
         // App Name
         row.add(
           new TextRenderable(this.cliRenderer, {
             content: k.app.padEnd(20),
-            fg: k.status === "found" ? "#50fa7b" : "#ff5555",
+            fg: color,
           })
         )
 
-        // Key
+        // Key with status indicator
+        let keyDisplay = k.key
+        if (k.status === "generated") keyDisplay = `${k.key} (generated)`
+
         row.add(
           new TextRenderable(this.cliRenderer, {
-            content: k.key,
-            fg: k.status === "found" ? "#f1fa8c" : "#6272a4",
+            content: keyDisplay,
+            fg: k.status === "found" || k.status === "generated" ? "#f1fa8c" : "#6272a4",
           })
         )
         content.add(row)
@@ -180,7 +333,7 @@ export class ApiKeyViewer extends BoxRenderable {
   }
 
   private async saveToEnv() {
-    const foundKeys = this.keys.filter((k) => k.status === "found")
+    const foundKeys = this.keys.filter((k) => k.status === "found" || k.status === "generated")
     if (foundKeys.length === 0) return
 
     try {

package/src/util/arch.ts

@@ -0,0 +1,78 @@
+/**
+ * Architecture Detection Utility
+ * Detects system architecture and checks app compatibility
+ */
+
+import type { AppDefinition, Architecture } from "../config/schema"
+
+/**
+ * Get the current system architecture
+ */
+export function getSystemArch(): Architecture {
+  const arch = process.arch
+  switch (arch) {
+    case "x64":
+    case "ia32":
+      return "x64"
+    case "arm64":
+      return "arm64"
+    case "arm":
+      return "arm32"
+    default:
+      return "x64" // Default to x64 for unknown
+  }
+}
+
+/**
+ * Check if an app is compatible with the given architecture
+ * Returns true if compatible (no issues), false if deprecated/broken
+ */
+export function isAppCompatible(app: AppDefinition, arch?: Architecture): boolean {
+  const systemArch = arch ?? getSystemArch()
+
+  if (!app.arch) {
+    return true // No arch restrictions = supports all
+  }
+
+  // Check if explicitly deprecated
+  if (app.arch.deprecated?.includes(systemArch)) {
+    return false
+  }
+
+  // If supported list exists, check if current arch is in it
+  if (app.arch.supported && !app.arch.supported.includes(systemArch)) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Get warning message for an app on the current architecture
+ * Returns null if no warning
+ */
+export function getArchWarning(app: AppDefinition, arch?: Architecture): string | null {
+  const systemArch = arch ?? getSystemArch()
+
+  if (!app.arch) {
+    return null
+  }
+
+  if (app.arch.deprecated?.includes(systemArch)) {
+    return app.arch.warning || `${app.name} has deprecated support for ${systemArch}`
+  }
+
+  if (app.arch.supported && !app.arch.supported.includes(systemArch)) {
+    return `${app.name} does not support ${systemArch} architecture`
+  }
+
+  return null
+}
+
+/**
+ * Check if app is deprecated (but might still work)
+ */
+export function isAppDeprecated(app: AppDefinition, arch?: Architecture): boolean {
+  const systemArch = arch ?? getSystemArch()
+  return app.arch?.deprecated?.includes(systemArch) ?? false
+}