@muhammedaksam/easiarr 0.1.0

package/src/docker/client.ts

@@ -0,0 +1,129 @@
+/**
+ * Docker Client
+ * Wrapper for docker compose commands using Bun.$
+ */
+
+import { $ } from "bun"
+import { getComposePath } from "../config/manager"
+
+export interface ContainerStatus {
+  name: string
+  status: "running" | "stopped" | "not_found"
+  ports?: string
+}
+
+export async function composeUp(): Promise<{
+  success: boolean
+  output: string
+}> {
+  try {
+    const composePath = getComposePath()
+    const result = await $`docker compose -f ${composePath} up -d`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function composeDown(): Promise<{
+  success: boolean
+  output: string
+}> {
+  try {
+    const composePath = getComposePath()
+    const result = await $`docker compose -f ${composePath} down`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function composeRestart(service?: string): Promise<{ success: boolean; output: string }> {
+  try {
+    const composePath = getComposePath()
+    const result = service
+      ? await $`docker compose -f ${composePath} restart ${service}`.text()
+      : await $`docker compose -f ${composePath} restart`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function composeStop(service?: string): Promise<{ success: boolean; output: string }> {
+  try {
+    const composePath = getComposePath()
+    const result = service
+      ? await $`docker compose -f ${composePath} stop ${service}`.text()
+      : await $`docker compose -f ${composePath} stop`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function composeStart(service?: string): Promise<{ success: boolean; output: string }> {
+  try {
+    const composePath = getComposePath()
+    const result = service
+      ? await $`docker compose -f ${composePath} start ${service}`.text()
+      : await $`docker compose -f ${composePath} start`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function getContainerStatuses(): Promise<ContainerStatus[]> {
+  try {
+    const composePath = getComposePath()
+    const result = await $`docker compose -f ${composePath} ps --format json`.text()
+
+    if (!result.trim()) {
+      return []
+    }
+
+    // Parse JSON lines output
+    const lines = result.trim().split("\n")
+    const statuses: ContainerStatus[] = []
+
+    for (const line of lines) {
+      try {
+        const container = JSON.parse(line)
+        statuses.push({
+          name: container.Name || container.Service,
+          status: container.State === "running" ? "running" : "stopped",
+          ports: container.Ports,
+        })
+      } catch {
+        // Skip malformed lines
+      }
+    }
+
+    return statuses
+  } catch {
+    return []
+  }
+}
+
+export async function pullImages(): Promise<{
+  success: boolean
+  output: string
+}> {
+  try {
+    const composePath = getComposePath()
+    const result = await $`docker compose -f ${composePath} pull`.text()
+    return { success: true, output: result }
+  } catch (error) {
+    return { success: false, output: String(error) }
+  }
+}
+
+export async function isDockerAvailable(): Promise<boolean> {
+  try {
+    await $`docker --version`.quiet()
+    return true
+  } catch {
+    return false
+  }
+}

package/src/docker/index.ts

@@ -0,0 +1 @@
+export * from "./client"

package/src/index.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+/**
+ * Easiarr Entry Point
+ * TUI tool for generating docker-compose files for the *arr ecosystem
+ */
+
+import { createCliRenderer } from "@opentui/core"
+import { App } from "./ui/App"
+
+async function main() {
+  const renderer = await createCliRenderer({
+    consoleOptions: {
+      startInDebugMode: false,
+    },
+  })
+
+  const app = new App(renderer)
+  await app.start()
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error)
+  process.exit(1)
+})

package/src/structure/manager.ts

@@ -0,0 +1,86 @@
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import type { EasiarrConfig, AppId } from "../config/schema"
+
+const BASE_DIRS = ["torrents", "usenet", "media"]
+
+// Map apps to their content type folders
+const CONTENT_TYPE_MAP: Partial<Record<AppId, string>> = {
+  radarr: "movies",
+  sonarr: "tv",
+  lidarr: "music",
+  readarr: "books",
+  mylar3: "comics",
+  whisparr: "adult",
+}
+
+export async function ensureDirectoryStructure(config: EasiarrConfig): Promise<void> {
+  try {
+    const dataRoot = join(config.rootDir, "data")
+
+    // Create base data directory
+    await mkdir(dataRoot, { recursive: true })
+
+    // 1. Create Base Directories (torrents, usenet, media)
+    for (const dir of BASE_DIRS) {
+      await mkdir(join(dataRoot, dir), { recursive: true })
+    }
+
+    // 2. Create Content Subdirectories based on enabled apps
+    const enabledApps = new Set(config.apps.filter((a) => a.enabled).map((a) => a.id))
+
+    for (const [appId, contentType] of Object.entries(CONTENT_TYPE_MAP)) {
+      if (enabledApps.has(appId as AppId)) {
+        // Create this content type in ALL base dirs to follow TRaSH standard
+        // (e.g. data/torrents/movies, data/usenet/movies, data/media/movies)
+        for (const base of BASE_DIRS) {
+          await mkdir(join(dataRoot, base, contentType), { recursive: true })
+        }
+      }
+    }
+
+    // 3. Special cases & MediaStack Extras
+
+    // Always create 'photos' in media (Personal photos)
+    await mkdir(join(dataRoot, "media", "photos"), { recursive: true })
+
+    // Always create 'console' and 'software' in torrents/usenet (Manual DL categories)
+    for (const base of ["torrents", "usenet"]) {
+      await mkdir(join(dataRoot, base, "console"), { recursive: true })
+      await mkdir(join(dataRoot, base, "software"), { recursive: true })
+      // Create 'watch' folder for manual .torrent/.nzb drops
+      await mkdir(join(dataRoot, base, "watch"), { recursive: true })
+
+      // 'complete' and 'incomplete' default folders
+      await mkdir(join(dataRoot, base, "complete"), { recursive: true })
+      await mkdir(join(dataRoot, base, "incomplete"), { recursive: true })
+    }
+
+    if (enabledApps.has("prowlarr")) {
+      // Prowlarr uncategorized downloads
+      await mkdir(join(dataRoot, "torrents", "prowlarr"), { recursive: true })
+      await mkdir(join(dataRoot, "usenet", "prowlarr"), { recursive: true })
+    }
+
+    if (enabledApps.has("filebot")) {
+      await mkdir(join(dataRoot, "filebot", "input"), { recursive: true })
+      await mkdir(join(dataRoot, "filebot", "output"), { recursive: true })
+    }
+
+    if (enabledApps.has("audiobookshelf")) {
+      // Audiobookshelf usually resides in media/audiobooks and media/podcasts
+      await mkdir(join(dataRoot, "media", "audiobooks"), { recursive: true })
+      await mkdir(join(dataRoot, "media", "podcasts"), { recursive: true })
+    }
+  } catch (error: unknown) {
+    const err = error as { code?: string; message: string }
+    if (err.code === "EACCES") {
+      console.error(`\n⚠ Warning: Permission denied when creating directories at ${config.rootDir}`)
+      console.error("  Please create the folders manually or check directory permissions.")
+      console.error(`  Error: ${err.message}\n`)
+      // Do not throw, allow setup to continue
+    } else {
+      throw error
+    }
+  }
+}

package/src/ui/App.ts

@@ -0,0 +1,95 @@
+/**
+ * Main Application Controller
+ * Manages navigation between screens
+ */
+
+import type { KeyEvent, CliRenderer } from "@opentui/core"
+import { BoxRenderable } from "@opentui/core"
+import { loadConfig, configExists, saveConfig } from "../config"
+import type { EasiarrConfig } from "../config/schema"
+import { MainMenu } from "./screens/MainMenu"
+import { QuickSetup } from "./screens/QuickSetup"
+import { AppManager } from "./screens/AppManager"
+import { ContainerControl } from "./screens/ContainerControl"
+import { AdvancedSettings } from "./screens/AdvancedSettings"
+
+export type Screen = "main" | "quickSetup" | "appManager" | "containerControl" | "advancedSettings"
+
+export class App {
+  private renderer: CliRenderer
+  private config: EasiarrConfig | null = null
+  private currentScreen: Screen = "main"
+  private screenContainer: BoxRenderable
+
+  constructor(renderer: CliRenderer) {
+    this.renderer = renderer
+    this.screenContainer = new BoxRenderable(renderer, {
+      id: "screen-container",
+      width: "100%",
+      height: "100%",
+    })
+    renderer.root.add(this.screenContainer)
+  }
+
+  async start(): Promise<void> {
+    // Load existing config or show quick setup
+    if (await configExists()) {
+      this.config = await loadConfig()
+    }
+
+    if (!this.config) {
+      this.navigateTo("quickSetup")
+    } else {
+      this.navigateTo("main")
+    }
+
+    // Handle exit
+    this.renderer.keyInput.on("keypress", (key: KeyEvent) => {
+      if (key.ctrl && key.name === "c") {
+        process.exit(0)
+      }
+    })
+  }
+
+  navigateTo(screen: Screen): void {
+    this.currentScreen = screen
+
+    // Clear all children from container
+    const children = this.screenContainer.getChildren()
+    for (const child of children) {
+      this.screenContainer.remove(child.id)
+    }
+
+    switch (screen) {
+      case "main":
+        new MainMenu(this.renderer, this.screenContainer, this, this.config!)
+        break
+      case "quickSetup":
+        new QuickSetup(this.renderer, this.screenContainer, this)
+        break
+      case "appManager":
+        new AppManager(this.renderer, this.screenContainer, this, this.config!)
+        break
+      case "containerControl":
+        new ContainerControl(this.renderer, this.screenContainer, this, this.config!)
+        break
+      case "advancedSettings":
+        new AdvancedSettings(this.renderer, this.screenContainer, this, this.config!)
+        break
+    }
+  }
+
+  async saveAndReload(config: EasiarrConfig): Promise<void> {
+    await saveConfig(config)
+    this.config = config
+    this.navigateTo("main")
+  }
+
+  setConfig(config: EasiarrConfig): void {
+    this.config = config
+  }
+
+  getConfig(): EasiarrConfig | null {
+    return this.config
+  }
+}

package/src/ui/components/ApplicationSelector.ts

@@ -0,0 +1,256 @@
+import {
+  BoxRenderable,
+  BoxOptions,
+  CliRenderer,
+  RenderContext,
+  TabSelectRenderable,
+  SelectRenderable,
+  TextRenderable,
+  SelectRenderableEvents,
+  KeyEvent,
+} from "@opentui/core"
+import { AppId } from "../../config/schema"
+import { CATEGORY_ORDER } from "../../apps/categories"
+import { getAppsByCategory } from "../../apps"
+
+export interface ApplicationSelectorOptions extends BoxOptions {
+  selectedApps: Set<AppId>
+  onToggle?: (appId: AppId, enabled: boolean) => void
+}
+
+export class ApplicationSelector extends BoxRenderable {
+  private selectedApps: Set<AppId>
+  private onToggle?: (appId: AppId, enabled: boolean) => void
+  private currentCategoryIndex: number = 0
+  private tabs: TabSelectRenderable
+  private appList: SelectRenderable
+  private warningBox: BoxRenderable
+  private _renderer: CliRenderer | RenderContext
+
+  // Track internal focus state
+  private activeComponent: "tabs" | "list" = "tabs"
+
+  constructor(renderer: CliRenderer | RenderContext, options: ApplicationSelectorOptions) {
+    super(renderer, {
+      ...options,
+      flexDirection: "column",
+    })
+
+    this._renderer = renderer
+    this.selectedApps = options.selectedApps
+    this.onToggle = options.onToggle
+
+    // 1. Conflict Warnings Area (Dynamic)
+    this.warningBox = new BoxRenderable(renderer, {
+      width: "100%",
+      flexDirection: "column",
+      marginBottom: 1,
+    })
+    this.add(this.warningBox)
+    this.updateWarnings()
+
+    // 2. Category Tabs
+    const tabOptions = this.getTabOptions()
+    this.tabs = new TabSelectRenderable(renderer, {
+      width: "100%" /** Explicit width needed for tabs usually */,
+      options: tabOptions,
+      tabWidth: 12,
+      showUnderline: false,
+      showDescription: false,
+      selectedBackgroundColor: "#4a9eff",
+      textColor: "#555555",
+    })
+
+    // Event listener replaced by manual key handling for instant switching
+    /*
+    this.tabs.on(TabSelectRenderableEvents.ITEM_SELECTED, (index) => {
+      if (this.currentCategoryIndex !== index) {
+        this.currentCategoryIndex = index
+        this.updateAppList()
+        this.activeComponent = "tabs"
+        this.tabs.focus()
+      }
+    })
+    */
+
+    this.add(this.tabs)
+
+    // Spacer
+    this.add(new TextRenderable(renderer, { content: " " }))
+
+    // 3. App List
+    this.appList = new SelectRenderable(renderer, {
+      width: "100%",
+      flexGrow: 1,
+      backgroundColor: "#151525",
+      focusedBackgroundColor: "#252545",
+      selectedBackgroundColor: "#3a4a6e",
+      showScrollIndicator: true,
+      options: [], // populated via updateAppList
+    })
+
+    this.appList.on(SelectRenderableEvents.ITEM_SELECTED, (index) => {
+      const category = CATEGORY_ORDER[this.currentCategoryIndex]
+      const apps = getAppsByCategory()[category.id] || []
+      const app = apps[index]
+
+      if (app) {
+        const isEnabled = !this.selectedApps.has(app.id)
+        if (isEnabled) {
+          this.selectedApps.add(app.id)
+        } else {
+          this.selectedApps.delete(app.id)
+        }
+
+        if (this.onToggle) {
+          this.onToggle(app.id, isEnabled)
+        }
+
+        // Refresh list to show checkmark
+        this.updateAppList()
+
+        // Refresh tabs to show counts
+        this.tabs.options = this.getTabOptions()
+        // Refresh warnings
+        this.updateWarnings()
+      }
+    })
+
+    this.add(this.appList)
+
+    // Initial population
+    this.updateAppList()
+  }
+
+  private getTabOptions() {
+    return CATEGORY_ORDER.map((cat) => {
+      const categoryApps = getAppsByCategory()[cat.id] || []
+      const selectedCount = categoryApps.filter((a) => this.selectedApps.has(a.id)).length
+      const countStr = selectedCount > 0 ? `(${selectedCount})` : ""
+      return {
+        name: `${cat.short}${countStr}`,
+        value: cat.id,
+        description: "", // Required by TabSelectOption
+      }
+    })
+  }
+
+  private updateAppList() {
+    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}`,
+    }))
+
+    this.appList.options = options
+  }
+
+  private updateWarnings() {
+    // Clear existing
+    const children = this.warningBox.getChildren()
+    children.forEach((c) => this.warningBox.remove(c.id))
+
+    const warnings = this.getConflictWarnings()
+
+    warnings.forEach((w, i) => {
+      this.warningBox.add(
+        new TextRenderable(this._renderer, {
+          id: `warning-${i}`,
+          content: `⚠ ${w}`,
+          fg: "#ffaa00",
+        })
+      )
+    })
+  }
+
+  private getConflictWarnings(): string[] {
+    const warnings: string[] = []
+    const check = (list: string[], msg: string) => {
+      const found = list.filter((id) => this.selectedApps.has(id as AppId))
+      if (found.length > 1) warnings.push(`${msg}: ${found.join(", ")}`)
+    }
+
+    check(["homarr", "heimdall", "homepage"], "Multiple dashboards")
+    check(["plex", "jellyfin"], "Multiple media servers")
+    check(["overseerr", "jellyseerr"], "Multiple request managers")
+    check(["prowlarr", "jackett"], "Multiple indexers")
+
+    return warnings
+  }
+
+  // --- Focus Management ---
+
+  focus() {
+    if (this.activeComponent === "tabs") {
+      // Don't focus tabs to avoid double key handling
+      this.appList.blur()
+    } else {
+      this.appList.focus()
+    }
+  }
+
+  handleKey(key: KeyEvent): boolean {
+    // Return true if handled
+    // Navigation between internal components
+    if (this.activeComponent === "tabs") {
+      if (key.name === "down") {
+        this.activeComponent = "list"
+        this.tabs.blur()
+        this.appList.focus()
+        return true
+      }
+      if (key.name === "left") {
+        this.switchCategory(-1)
+        return true
+      }
+      if (key.name === "right") {
+        this.switchCategory(1)
+        return true
+      }
+    } else {
+      // List active
+      if (key.name === "up" && this.appList.selectedIndex === 0) {
+        this.activeComponent = "tabs"
+        this.appList.blur()
+        return true
+      }
+
+      // Allow switching category from list too?
+      if (key.name === "left" || key.name === "[") {
+        this.switchCategory(-1)
+        return true
+      }
+      if (key.name === "right" || key.name === "]") {
+        this.switchCategory(1)
+        return true
+      }
+    }
+
+    return false
+  }
+
+  private toggleFocus() {
+    if (this.activeComponent === "tabs") {
+      this.activeComponent = "list"
+      this.appList.focus()
+    } else {
+      this.activeComponent = "tabs"
+      this.appList.blur()
+    }
+  }
+
+  private switchCategory(delta: number) {
+    let newIndex = this.currentCategoryIndex + delta
+    if (newIndex < 0) newIndex = 0
+    if (newIndex >= CATEGORY_ORDER.length) newIndex = CATEGORY_ORDER.length - 1
+
+    if (newIndex !== this.currentCategoryIndex) {
+      this.currentCategoryIndex = newIndex
+      // Sync Tabs
+      this.tabs.setSelectedIndex(newIndex)
+      this.updateAppList()
+    }
+  }
+}

package/src/ui/components/FileEditor.ts

@@ -0,0 +1,91 @@
+import {
+  BoxRenderable,
+  TextareaRenderable,
+  TextRenderable,
+  CliRenderer,
+  RenderContext,
+  BoxOptions,
+  RGBA,
+  KeyEvent,
+} from "@opentui/core"
+
+export interface FileEditorOptions extends BoxOptions {
+  filename: string
+  initialContent: string
+  onSave: (content: string) => void
+  onCancel: () => void
+}
+
+export class FileEditor extends BoxRenderable {
+  private textarea: TextareaRenderable
+  private helpText: TextRenderable
+  private onSave: (content: string) => void
+  private onCancel: () => void
+  private filename: string
+  private renderer: CliRenderer
+  private keyHandler: ((k: KeyEvent) => void) | null = null
+
+  constructor(renderer: CliRenderer | RenderContext, options: FileEditorOptions) {
+    super(renderer, {
+      ...options,
+      border: true,
+      borderStyle: "double",
+      title: `Editing: ${options.filename}`,
+      titleAlignment: "center",
+      flexDirection: "column",
+    })
+
+    this.renderer = renderer as CliRenderer
+    this.onSave = options.onSave
+    this.onCancel = options.onCancel
+    this.filename = options.filename
+
+    this.textarea = new TextareaRenderable(renderer, {
+      width: "100%",
+      flexGrow: 1, // fill remaining space
+      initialValue: options.initialContent,
+      showCursor: true,
+      wrapMode: "none",
+    })
+    this.add(this.textarea)
+
+    // Help Footer
+    this.helpText = new TextRenderable(renderer, {
+      content: "Ctrl+S: Save  |  ESC: Cancel",
+      width: "100%",
+      height: 1,
+      fg: RGBA.fromHex("#888888"),
+    })
+    this.add(this.helpText)
+
+    // Use global key handler for reliability
+    this.keyHandler = (key: KeyEvent) => {
+      // If we are not visible or destroyed, don't handle keys
+      if (this.isDestroyed || !this.visible) return
+
+      if (key.name === "s" && key.ctrl) {
+        this.onSave(this.textarea.plainText)
+      } else if (key.name === "escape") {
+        this.onCancel()
+      }
+    }
+
+    this.renderer.keyInput.on("keypress", this.keyHandler)
+  }
+
+  override destroy(): void {
+    if (this.keyHandler) {
+      this.renderer.keyInput.off("keypress", this.keyHandler)
+      this.keyHandler = null
+    }
+    super.destroy()
+  }
+
+  focus() {
+    this.textarea.focus()
+  }
+
+  getValue(): string {
+    return this.textarea.plainText
+  }
+}