@muhammedaksam/easiarr 0.7.9 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "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/jellyfin-api.ts

@@ -0,0 +1,359 @@
+/**
+ * Jellyfin API Client
+ * Handles setup wizard automation and media library management
+ */
+
+import { debugLog } from "../utils/debug"
+
+// ==========================================
+// Startup Wizard Types
+// ==========================================
+
+export interface StartupConfiguration {
+  UICulture?: string
+  MetadataCountryCode?: string
+  PreferredMetadataLanguage?: string
+}
+
+export interface StartupUser {
+  Name: string
+  Pw: string
+}
+
+export interface StartupRemoteAccess {
+  EnableRemoteAccess: boolean
+  EnableAutomaticPortMapping: boolean
+}
+
+// ==========================================
+// Library Types
+// ==========================================
+
+export interface VirtualFolderInfo {
+  Name: string
+  Locations: string[]
+  CollectionType: LibraryType
+  ItemId?: string
+}
+
+export type LibraryType =
+  | "movies"
+  | "tvshows"
+  | "music"
+  | "books"
+  | "homevideos"
+  | "musicvideos"
+  | "photos"
+  | "playlists"
+  | "boxsets"
+
+export interface AddVirtualFolderOptions {
+  name: string
+  collectionType: LibraryType
+  paths: string[]
+  refreshLibrary?: boolean
+}
+
+// ==========================================
+// System Types
+// ==========================================
+
+export interface SystemInfo {
+  ServerName: string
+  Version: string
+  Id: string
+  OperatingSystem: string
+  StartupWizardCompleted: boolean
+}
+
+export interface AuthResult {
+  AccessToken: string
+  ServerId: string
+  User: {
+    Id: string
+    Name: string
+  }
+}
+
+// ==========================================
+// Jellyfin Client
+// ==========================================
+
+export class JellyfinClient {
+  private baseUrl: string
+  private accessToken?: string
+
+  constructor(host: string, port: number, accessToken?: string) {
+    this.baseUrl = `http://${host}:${port}`
+    this.accessToken = accessToken
+  }
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      // Jellyfin requires client identification
+      "X-Emby-Authorization":
+        'MediaBrowser Client="Easiarr", Device="Server", DeviceId="easiarr-setup", Version="1.0.0"' +
+        (this.accessToken ? `, Token="${this.accessToken}"` : ""),
+      ...((options.headers as Record<string, string>) || {}),
+    }
+
+    debugLog("JellyfinAPI", `${options.method || "GET"} ${url}`)
+    if (options.body) {
+      debugLog("JellyfinAPI", `Request Body: ${options.body}`)
+    }
+
+    const response = await fetch(url, { ...options, headers })
+    const text = await response.text()
+
+    debugLog("JellyfinAPI", `Response ${response.status} from ${endpoint}`)
+    if (text && text.length < 2000) {
+      debugLog("JellyfinAPI", `Response Body: ${text}`)
+    }
+
+    if (!response.ok) {
+      throw new Error(`Jellyfin API request failed: ${response.status} ${response.statusText} - ${text}`)
+    }
+
+    if (!text) return {} as T
+    return JSON.parse(text) as T
+  }
+
+  // ==========================================
+  // Setup Wizard Methods (no auth required)
+  // ==========================================
+
+  /**
+   * Check if the startup wizard has been completed
+   */
+  async isStartupComplete(): Promise<boolean> {
+    try {
+      const info = await this.request<SystemInfo>("/System/Info/Public")
+      return info.StartupWizardCompleted === true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get current startup configuration
+   */
+  async getStartupConfiguration(): Promise<StartupConfiguration> {
+    return this.request<StartupConfiguration>("/Startup/Configuration")
+  }
+
+  /**
+   * Set startup configuration (metadata language, UI culture)
+   */
+  async setStartupConfiguration(config: StartupConfiguration): Promise<void> {
+    await this.request("/Startup/Configuration", {
+      method: "POST",
+      body: JSON.stringify(config),
+    })
+  }
+
+  /**
+   * Create the initial admin user
+   */
+  async createAdminUser(name: string, password: string): Promise<void> {
+    const user: StartupUser = { Name: name, Pw: password }
+    await this.request("/Startup/User", {
+      method: "POST",
+      body: JSON.stringify(user),
+    })
+  }
+
+  /**
+   * Configure remote access settings
+   */
+  async setRemoteAccess(enableRemote: boolean, enableUPnP: boolean = false): Promise<void> {
+    const config: StartupRemoteAccess = {
+      EnableRemoteAccess: enableRemote,
+      EnableAutomaticPortMapping: enableUPnP,
+    }
+    await this.request("/Startup/RemoteAccess", {
+      method: "POST",
+      body: JSON.stringify(config),
+    })
+  }
+
+  /**
+   * Complete the startup wizard
+   */
+  async completeStartup(): Promise<void> {
+    await this.request("/Startup/Complete", {
+      method: "POST",
+    })
+  }
+
+  /**
+   * Run the full setup wizard with sensible defaults
+   */
+  async runSetupWizard(
+    adminName: string,
+    adminPassword: string,
+    options: {
+      uiCulture?: string
+      metadataCountry?: string
+      metadataLanguage?: string
+      enableRemoteAccess?: boolean
+      enableUPnP?: boolean
+    } = {}
+  ): Promise<void> {
+    const {
+      uiCulture = "en-US",
+      metadataCountry = "US",
+      metadataLanguage = "en",
+      enableRemoteAccess = true,
+      enableUPnP = false,
+    } = options
+
+    // Step 1: Set UI culture and metadata language
+    await this.setStartupConfiguration({
+      UICulture: uiCulture,
+      MetadataCountryCode: metadataCountry,
+      PreferredMetadataLanguage: metadataLanguage,
+    })
+
+    // Step 2: Create admin user
+    await this.createAdminUser(adminName, adminPassword)
+
+    // Step 3: Configure remote access
+    await this.setRemoteAccess(enableRemoteAccess, enableUPnP)
+
+    // Step 4: Complete the wizard
+    await this.completeStartup()
+  }
+
+  // ==========================================
+  // Authentication (post-setup)
+  // ==========================================
+
+  /**
+   * Authenticate with username/password and get access token
+   */
+  async authenticate(username: string, password: string): Promise<AuthResult> {
+    const result = await this.request<AuthResult>("/Users/AuthenticateByName", {
+      method: "POST",
+      body: JSON.stringify({
+        Username: username,
+        Pw: password,
+      }),
+    })
+
+    // Store token for subsequent requests
+    this.accessToken = result.AccessToken
+    return result
+  }
+
+  /**
+   * Set access token directly (if already known)
+   */
+  setAccessToken(token: string): void {
+    this.accessToken = token
+  }
+
+  // ==========================================
+  // Library Management (requires auth)
+  // ==========================================
+
+  /**
+   * Get all virtual folders (media libraries)
+   */
+  async getVirtualFolders(): Promise<VirtualFolderInfo[]> {
+    return this.request<VirtualFolderInfo[]>("/Library/VirtualFolders")
+  }
+
+  /**
+   * Add a new media library
+   */
+  async addVirtualFolder(options: AddVirtualFolderOptions): Promise<void> {
+    const params = new URLSearchParams({
+      name: options.name,
+      collectionType: options.collectionType,
+      refreshLibrary: String(options.refreshLibrary ?? true),
+    })
+
+    // Paths need to be added to the body
+    await this.request(`/Library/VirtualFolders?${params.toString()}`, {
+      method: "POST",
+      body: JSON.stringify({
+        LibraryOptions: {
+          PathInfos: options.paths.map((path) => ({ Path: path })),
+        },
+      }),
+    })
+  }
+
+  /**
+   * Add default media libraries based on common media stack paths
+   */
+  async addDefaultLibraries(): Promise<void> {
+    const defaultLibraries: AddVirtualFolderOptions[] = [
+      { name: "Movies", collectionType: "movies", paths: ["/data/media/movies"] },
+      { name: "TV Shows", collectionType: "tvshows", paths: ["/data/media/tv"] },
+      { name: "Music", collectionType: "music", paths: ["/data/media/music"] },
+    ]
+
+    for (const lib of defaultLibraries) {
+      try {
+        await this.addVirtualFolder(lib)
+      } catch (error) {
+        // Library might already exist, continue with others
+        debugLog("JellyfinAPI", `Failed to add library ${lib.name}: ${error}`)
+      }
+    }
+  }
+
+  // ==========================================
+  // API Key Management (requires auth)
+  // ==========================================
+
+  /**
+   * Create an API key for external access (e.g., Homepage widget)
+   */
+  async createApiKey(appName: string): Promise<string> {
+    await this.request(`/Auth/Keys?app=${encodeURIComponent(appName)}`, {
+      method: "POST",
+    })
+
+    // Get all keys and find the one we just created
+    const keys = await this.getApiKeys()
+    const key = keys.find((k) => k.AppName === appName)
+    return key?.AccessToken || ""
+  }
+
+  /**
+   * Get all API keys
+   */
+  async getApiKeys(): Promise<{ AccessToken: string; AppName: string; DateCreated: string }[]> {
+    const result = await this.request<{
+      Items: { AccessToken: string; AppName: string; DateCreated: string }[]
+    }>("/Auth/Keys")
+    return result.Items || []
+  }
+
+  // ==========================================
+  // Health Check
+  // ==========================================
+
+  /**
+   * Check if Jellyfin is running and accessible
+   */
+  async isHealthy(): Promise<boolean> {
+    try {
+      await this.request<SystemInfo>("/System/Info/Public")
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get public system info (no auth required)
+   */
+  async getPublicSystemInfo(): Promise<SystemInfo> {
+    return this.request<SystemInfo>("/System/Info/Public")
+  }
+}

package/src/apps/registry.ts

@@ -397,7 +397,7 @@ export const APPS: Record<AppId, AppDefinition> = {
     name: "Jellyseerr",
     description: "Request management for Jellyfin",
     category: "request",
-    defaultPort: 5056,
+    defaultPort: 5055,
     image: "fallenbagel/jellyseerr:latest",
     puid: 13012,
     pgid: 13000,

package/src/ui/screens/ApiKeyViewer.ts

@@ -188,7 +188,7 @@ export class ApiKeyViewer extends BoxRenderable {
     }
 
     // Will attempt to initialize/login when saving
-    const globalPassword = env["PASSWORD_GLOBAL"]
+    const globalPassword = env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
     if (!globalPassword) {
       this.keys.push({
         appId: "portainer",
@@ -439,7 +439,7 @@ export class ApiKeyViewer extends BoxRenderable {
   private async initializePortainer(_updates: Record<string, string>) {
     const env = readEnvSync()
     const globalUsername = env["USERNAME_GLOBAL"] || "admin"
-    const globalPassword = env["PASSWORD_GLOBAL"]
+    const globalPassword = env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
 
     if (!globalPassword) return
 

package/src/ui/screens/AppConfigurator.ts

@@ -84,9 +84,9 @@ export class AppConfigurator extends BoxRenderable {
   private loadSavedCredentials() {
     const env = readEnvSync()
     if (env.USERNAME_GLOBAL) this.globalUsername = env.USERNAME_GLOBAL
-    if (env.PASSWORD_GLOBAL) this.globalPassword = env.PASSWORD_GLOBAL
+    this.globalPassword = env.PASSWORD_GLOBAL || "Ch4ng3m3!1234securityReasons"
     if (env.PASSWORD_QBITTORRENT) this.qbPass = env.PASSWORD_QBITTORRENT
-    if (env.SABNZBD_API_KEY) this.sabApiKey = env.SABNZBD_API_KEY
+    if (env.API_KEY_SABNZBD) this.sabApiKey = env.API_KEY_SABNZBD
   }
 
   private renderCredentialsPrompt() {
@@ -612,7 +612,7 @@ export class AppConfigurator extends BoxRenderable {
       if (type === "qbittorrent" && this.qbPass) {
         updates.PASSWORD_QBITTORRENT = this.qbPass
       } else if (type === "sabnzbd" && this.sabApiKey) {
-        updates.SABNZBD_API_KEY = this.sabApiKey
+        updates.API_KEY_SABNZBD = this.sabApiKey
       }
       await updateEnv(updates)
     } catch {

package/src/ui/screens/FullAutoSetup.ts

@@ -10,6 +10,7 @@ import { ArrApiClient, type AddRootFolderOptions } from "../../api/arr-api"
 import { ProwlarrClient, type ArrAppType } from "../../api/prowlarr-api"
 import { QBittorrentClient, type QBittorrentCategory } from "../../api/qbittorrent-api"
 import { PortainerApiClient } from "../../api/portainer-api"
+import { JellyfinClient } from "../../api/jellyfin-api"
 import { getApp } from "../../apps/registry"
 // import type { AppId } from "../../config/schema"
 import { getCategoriesForApps } from "../../utils/categories"
@@ -66,7 +67,7 @@ export class FullAutoSetup extends BoxRenderable {
 
     this.env = readEnvSync()
     this.globalUsername = this.env["USERNAME_GLOBAL"] || "admin"
-    this.globalPassword = this.env["PASSWORD_GLOBAL"] || ""
+    this.globalPassword = this.env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
 
     this.initKeyHandler()
     this.initSteps()
@@ -81,6 +82,7 @@ export class FullAutoSetup extends BoxRenderable {
       { name: "FlareSolverr", status: "pending" },
       { name: "qBittorrent", status: "pending" },
       { name: "Portainer", status: "pending" },
+      { name: "Jellyfin", status: "pending" },
     ]
   }
 
@@ -129,6 +131,9 @@ export class FullAutoSetup extends BoxRenderable {
     // Step 6: Portainer
     await this.setupPortainer()
 
+    // Step 7: Jellyfin
+    await this.setupJellyfin()
+
     this.isRunning = false
     this.isDone = true
     this.refreshContent()
@@ -407,6 +412,46 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupJellyfin(): Promise<void> {
+    this.updateStep("Jellyfin", "running")
+    this.refreshContent()
+
+    const jellyfinConfig = this.config.apps.find((a) => a.id === "jellyfin" && a.enabled)
+    if (!jellyfinConfig) {
+      this.updateStep("Jellyfin", "skipped", "Not enabled")
+      this.refreshContent()
+      return
+    }
+
+    try {
+      const port = jellyfinConfig.port || 8096
+      const client = new JellyfinClient("localhost", port)
+
+      // Check if reachable
+      const healthy = await client.isHealthy()
+      if (!healthy) {
+        this.updateStep("Jellyfin", "skipped", "Not reachable yet")
+        this.refreshContent()
+        return
+      }
+
+      // Check if already set up
+      const isComplete = await client.isStartupComplete()
+      if (isComplete) {
+        this.updateStep("Jellyfin", "skipped", "Already configured")
+        this.refreshContent()
+        return
+      }
+
+      // Run setup wizard
+      await client.runSetupWizard(this.globalUsername, this.globalPassword)
+      this.updateStep("Jellyfin", "success", "Setup wizard completed")
+    } catch (e) {
+      this.updateStep("Jellyfin", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private updateStep(name: string, status: SetupStep["status"], message?: string): void {
     const step = this.steps.find((s) => s.name === name)
     if (step) {

package/src/ui/screens/JellyfinSetup.ts

@@ -0,0 +1,471 @@
+/**
+ * Jellyfin Setup Screen
+ * Automates the Jellyfin setup wizard via API
+ */
+
+import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
+import { createPageLayout } from "../components/PageLayout"
+import { EasiarrConfig } from "../../config/schema"
+import { JellyfinClient } from "../../api/jellyfin-api"
+import { readEnvSync, writeEnvSync } from "../../utils/env"
+import { debugLog } from "../../utils/debug"
+
+interface SetupResult {
+  name: string
+  status: "pending" | "configuring" | "success" | "error" | "skipped"
+  message?: string
+}
+
+type Step = "menu" | "running" | "done"
+
+export class JellyfinSetup extends BoxRenderable {
+  private config: EasiarrConfig
+  private cliRenderer: CliRenderer
+  private onBack: () => void
+  private keyHandler!: (key: KeyEvent) => void
+  private results: SetupResult[] = []
+  private currentStep: Step = "menu"
+  private contentBox!: BoxRenderable
+  private menuIndex = 0
+  private jellyfinClient: JellyfinClient | null = null
+
+  constructor(cliRenderer: CliRenderer, config: EasiarrConfig, onBack: () => void) {
+    const { container: pageContainer, content: contentBox } = createPageLayout(cliRenderer, {
+      title: "Jellyfin Setup",
+      stepInfo: "Configure Jellyfin via API",
+      footerHint: [
+        { type: "key", key: "↑↓", value: "Navigate" },
+        { type: "key", key: "Enter", value: "Select" },
+        { type: "key", key: "Esc", value: "Back" },
+      ],
+    })
+    super(cliRenderer, { width: "100%", height: "100%" })
+    this.add(pageContainer)
+
+    this.config = config
+    this.cliRenderer = cliRenderer
+    this.onBack = onBack
+    this.contentBox = contentBox
+
+    this.initJellyfinClient()
+    this.initKeyHandler()
+    this.refreshContent()
+  }
+
+  private initJellyfinClient(): void {
+    const jellyfinConfig = this.config.apps.find((a) => a.id === "jellyfin")
+    if (jellyfinConfig?.enabled) {
+      const port = jellyfinConfig.port || 8096
+      this.jellyfinClient = new JellyfinClient("localhost", port)
+    }
+  }
+
+  private initKeyHandler(): void {
+    this.keyHandler = (key: KeyEvent) => {
+      debugLog("Jellyfin", `Key: ${key.name}, step=${this.currentStep}`)
+
+      if (key.name === "escape" || (key.name === "c" && key.ctrl)) {
+        if (this.currentStep === "menu") {
+          this.cleanup()
+        } else if (this.currentStep === "done") {
+          this.currentStep = "menu"
+          this.refreshContent()
+        }
+        return
+      }
+
+      if (this.currentStep === "menu") {
+        this.handleMenuKeys(key)
+      } else if (this.currentStep === "done") {
+        if (key.name === "return" || key.name === "escape") {
+          this.currentStep = "menu"
+          this.refreshContent()
+        }
+      }
+    }
+    this.cliRenderer.keyInput.on("keypress", this.keyHandler)
+    debugLog("Jellyfin", "Key handler registered")
+  }
+
+  private handleMenuKeys(key: KeyEvent): void {
+    const menuItems = this.getMenuItems()
+
+    if (key.name === "up" && this.menuIndex > 0) {
+      this.menuIndex--
+      this.refreshContent()
+    } else if (key.name === "down" && this.menuIndex < menuItems.length - 1) {
+      this.menuIndex++
+      this.refreshContent()
+    } else if (key.name === "return") {
+      this.executeMenuItem(this.menuIndex)
+    }
+  }
+
+  private getMenuItems(): { name: string; description: string; action: () => void }[] {
+    return [
+      {
+        name: "🚀 Run Setup Wizard",
+        description: "Create admin user and complete initial setup",
+        action: () => this.runSetupWizard(),
+      },
+      {
+        name: "📚 Add Default Libraries",
+        description: "Add Movies, TV Shows, Music libraries",
+        action: () => this.addDefaultLibraries(),
+      },
+      {
+        name: "🔑 Generate API Key",
+        description: "Create API key for Homepage widget",
+        action: () => this.generateApiKey(),
+      },
+      {
+        name: "↩️  Back",
+        description: "Return to main menu",
+        action: () => this.cleanup(),
+      },
+    ]
+  }
+
+  private executeMenuItem(index: number): void {
+    const items = this.getMenuItems()
+    if (index >= 0 && index < items.length) {
+      items[index].action()
+    }
+  }
+
+  private async runSetupWizard(): Promise<void> {
+    if (!this.jellyfinClient) {
+      this.results = [{ name: "Jellyfin", status: "error", message: "Not enabled in config" }]
+      this.currentStep = "done"
+      this.refreshContent()
+      return
+    }
+
+    this.currentStep = "running"
+    this.results = [
+      { name: "Check status", status: "configuring" },
+      { name: "Set metadata language", status: "pending" },
+      { name: "Create admin user", status: "pending" },
+      { name: "Configure remote access", status: "pending" },
+      { name: "Complete wizard", status: "pending" },
+    ]
+    this.refreshContent()
+
+    try {
+      // Step 1: Check if already set up
+      const isComplete = await this.jellyfinClient.isStartupComplete()
+      if (isComplete) {
+        this.results[0].status = "skipped"
+        this.results[0].message = "Already configured"
+        this.results.slice(1).forEach((r) => {
+          r.status = "skipped"
+          r.message = "Wizard already completed"
+        })
+        this.currentStep = "done"
+        this.refreshContent()
+        return
+      }
+      this.results[0].status = "success"
+      this.results[0].message = "Wizard needed"
+      this.refreshContent()
+
+      // Step 2: Set metadata language
+      this.results[1].status = "configuring"
+      this.refreshContent()
+      await this.jellyfinClient.setStartupConfiguration({
+        UICulture: "en-US",
+        MetadataCountryCode: "US",
+        PreferredMetadataLanguage: "en",
+      })
+      this.results[1].status = "success"
+      this.refreshContent()
+
+      // Step 3: Create admin user
+      this.results[2].status = "configuring"
+      this.refreshContent()
+      const env = readEnvSync()
+      const username = env["USERNAME_GLOBAL"] || "admin"
+      const password = env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
+      await this.jellyfinClient.createAdminUser(username, password)
+      this.results[2].status = "success"
+      this.results[2].message = `User: ${username}`
+      this.refreshContent()
+
+      // Step 4: Configure remote access
+      this.results[3].status = "configuring"
+      this.refreshContent()
+      await this.jellyfinClient.setRemoteAccess(true, false)
+      this.results[3].status = "success"
+      this.refreshContent()
+
+      // Step 5: Complete wizard
+      this.results[4].status = "configuring"
+      this.refreshContent()
+      await this.jellyfinClient.completeStartup()
+      this.results[4].status = "success"
+      this.refreshContent()
+    } catch (error) {
+      const current = this.results.find((r) => r.status === "configuring")
+      if (current) {
+        current.status = "error"
+        current.message = error instanceof Error ? error.message : String(error)
+      }
+    }
+
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
+  private async addDefaultLibraries(): Promise<void> {
+    if (!this.jellyfinClient) {
+      this.results = [{ name: "Jellyfin", status: "error", message: "Not enabled in config" }]
+      this.currentStep = "done"
+      this.refreshContent()
+      return
+    }
+
+    this.currentStep = "running"
+    this.results = [
+      { name: "Authenticate", status: "configuring" },
+      { name: "Movies", status: "pending" },
+      { name: "TV Shows", status: "pending" },
+      { name: "Music", status: "pending" },
+    ]
+    this.refreshContent()
+
+    try {
+      // Authenticate first
+      const env = readEnvSync()
+      const username = env["USERNAME_GLOBAL"] || "admin"
+      const password = env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
+      await this.jellyfinClient.authenticate(username, password)
+      this.results[0].status = "success"
+      this.refreshContent()
+
+      // Add libraries
+      const libraries = [
+        { name: "Movies", collectionType: "movies" as const, paths: ["/data/media/movies"] },
+        { name: "TV Shows", collectionType: "tvshows" as const, paths: ["/data/media/tv"] },
+        { name: "Music", collectionType: "music" as const, paths: ["/data/media/music"] },
+      ]
+
+      for (let i = 0; i < libraries.length; i++) {
+        const lib = libraries[i]
+        this.results[i + 1].status = "configuring"
+        this.refreshContent()
+
+        try {
+          await this.jellyfinClient.addVirtualFolder(lib)
+          this.results[i + 1].status = "success"
+          this.results[i + 1].message = lib.paths[0]
+        } catch (error) {
+          this.results[i + 1].status = "error"
+          this.results[i + 1].message = error instanceof Error ? error.message : String(error)
+        }
+        this.refreshContent()
+      }
+    } catch (error) {
+      this.results[0].status = "error"
+      this.results[0].message = error instanceof Error ? error.message : String(error)
+    }
+
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
+  private async generateApiKey(): Promise<void> {
+    if (!this.jellyfinClient) {
+      this.results = [{ name: "Jellyfin", status: "error", message: "Not enabled in config" }]
+      this.currentStep = "done"
+      this.refreshContent()
+      return
+    }
+
+    this.currentStep = "running"
+    this.results = [
+      { name: "Authenticate", status: "configuring" },
+      { name: "Generate API Key", status: "pending" },
+      { name: "Save to .env", status: "pending" },
+    ]
+    this.refreshContent()
+
+    try {
+      // Authenticate first
+      const env = readEnvSync()
+      const username = env["USERNAME_GLOBAL"] || "admin"
+      const password = env["PASSWORD_GLOBAL"] || "Ch4ng3m3!1234securityReasons"
+      await this.jellyfinClient.authenticate(username, password)
+      this.results[0].status = "success"
+      this.refreshContent()
+
+      // Generate API key
+      this.results[1].status = "configuring"
+      this.refreshContent()
+      const apiKey = await this.jellyfinClient.createApiKey("Easiarr")
+      if (!apiKey) {
+        throw new Error("Failed to create API key")
+      }
+      this.results[1].status = "success"
+      this.results[1].message = `Key: ${apiKey.substring(0, 8)}...`
+      this.refreshContent()
+
+      // Save to .env
+      this.results[2].status = "configuring"
+      this.refreshContent()
+      env["API_KEY_JELLYFIN"] = apiKey
+      writeEnvSync(env)
+      this.results[2].status = "success"
+      this.results[2].message = "Saved as API_KEY_JELLYFIN"
+      this.refreshContent()
+    } catch (error) {
+      const current = this.results.find((r) => r.status === "configuring")
+      if (current) {
+        current.status = "error"
+        current.message = error instanceof Error ? error.message : String(error)
+      }
+    }
+
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
+  private refreshContent(): void {
+    this.contentBox.getChildren().forEach((child) => child.destroy())
+
+    if (this.currentStep === "menu") {
+      this.renderMenu()
+    } else {
+      this.renderResults()
+    }
+  }
+
+  private renderMenu(): void {
+    // Check health status
+    this.checkHealth()
+
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "Select an action:\n\n",
+        fg: "#aaaaaa",
+      })
+    )
+
+    this.getMenuItems().forEach((item, idx) => {
+      const pointer = idx === this.menuIndex ? "→ " : "  "
+      const fg = idx === this.menuIndex ? "#50fa7b" : "#8be9fd"
+
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: `${pointer}${item.name}\n`,
+          fg,
+        })
+      )
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: `    ${item.description}\n\n`,
+          fg: "#6272a4",
+        })
+      )
+    })
+  }
+
+  private async checkHealth(): Promise<void> {
+    if (!this.jellyfinClient) {
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: "⚠️ Jellyfin not enabled in config!\n\n",
+          fg: "#ff5555",
+        })
+      )
+      return
+    }
+
+    try {
+      const isHealthy = await this.jellyfinClient.isHealthy()
+      const isComplete = isHealthy ? await this.jellyfinClient.isStartupComplete() : false
+
+      if (!isHealthy) {
+        this.contentBox.add(
+          new TextRenderable(this.cliRenderer, {
+            content: "⚠️ Jellyfin is not reachable. Make sure the container is running.\n\n",
+            fg: "#ffb86c",
+          })
+        )
+      } else if (!isComplete) {
+        this.contentBox.add(
+          new TextRenderable(this.cliRenderer, {
+            content: "✨ Jellyfin needs initial setup. Run 'Setup Wizard' to configure.\n\n",
+            fg: "#50fa7b",
+          })
+        )
+      } else {
+        this.contentBox.add(
+          new TextRenderable(this.cliRenderer, {
+            content: "✓ Jellyfin is running and configured.\n\n",
+            fg: "#50fa7b",
+          })
+        )
+      }
+    } catch {
+      // Ignore errors in health check display
+    }
+  }
+
+  private renderResults(): void {
+    const headerText = this.currentStep === "done" ? "Results:\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
+        case "skipped":
+          status = "⊘"
+          fg = "#6272a4"
+          break
+      }
+
+      let content = `${status} ${result.name}`
+      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/ui/screens/MainMenu.ts

@@ -17,6 +17,7 @@ import { QBittorrentSetup } from "./QBittorrentSetup"
 import { FullAutoSetup } from "./FullAutoSetup"
 import { MonitorDashboard } from "./MonitorDashboard"
 import { HomepageSetup } from "./HomepageSetup"
+import { JellyfinSetup } from "./JellyfinSetup"
 
 export class MainMenu {
   private renderer: RenderContext
@@ -134,6 +135,10 @@ export class MainMenu {
           name: "🏠 Homepage Setup",
           description: "Generate Homepage dashboard config",
         },
+        {
+          name: "🎬 Jellyfin Setup",
+          description: "Run Jellyfin setup wizard via API",
+        },
         { name: "❌ Exit", description: "Close easiarr" },
       ],
     })
@@ -243,7 +248,18 @@ export class MainMenu {
           this.container.add(homepageSetup)
           break
         }
-        case 12:
+        case 12: {
+          // Jellyfin Setup
+          this.menu.blur()
+          this.page.visible = false
+          const jellyfinSetup = new JellyfinSetup(this.renderer as CliRenderer, this.config, () => {
+            this.page.visible = true
+            this.menu.focus()
+          })
+          this.container.add(jellyfinSetup)
+          break
+        }
+        case 13:
           process.exit(0)
           break
       }

package/src/utils/env.ts

@@ -3,7 +3,7 @@
  * Shared functions for reading/writing .env files
  */
 
-import { existsSync, readFileSync } from "node:fs"
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
 import { writeFile, readFile } from "node:fs/promises"
 import { networkInterfaces } from "node:os"
 import { getComposePath } from "../config/manager"
@@ -82,6 +82,22 @@ export function readEnvSync(): Record<string, string> {
   }
 }
 
+/**
+ * Write to .env file synchronously, merging with existing values
+ * Preserves existing keys not in the updates object
+ */
+export function writeEnvSync(updates: Record<string, string>): void {
+  const envPath = getEnvPath()
+  const current = readEnvSync()
+
+  // Merge updates into current
+  const merged = { ...current, ...updates }
+
+  // Write back
+  const content = serializeEnv(merged)
+  writeFileSync(envPath, content, "utf-8")
+}
+
 /**
  * Read the .env file asynchronously
  */