@muhammedaksam/easiarr 0.6.2 → 0.7.1

package/src/ui/screens/HomepageSetup.ts

@@ -0,0 +1,306 @@
+/**
+ * Homepage Setup Screen
+ * Configure Homepage dashboard with enabled apps
+ */
+
+import { BoxRenderable, CliRenderer, TextRenderable, KeyEvent } from "@opentui/core"
+import { createPageLayout } from "../components/PageLayout"
+import { EasiarrConfig } from "../../config/schema"
+import { saveHomepageConfig, generateServicesYaml } from "../../config/homepage-config"
+import { getApp } from "../../apps/registry"
+
+interface SetupResult {
+  name: string
+  status: "pending" | "configuring" | "success" | "error" | "skipped"
+  message?: string
+}
+
+type Step = "menu" | "generating" | "preview" | "done"
+
+export class HomepageSetup 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 pageContainer!: BoxRenderable
+  private menuIndex = 0
+  private previewContent = ""
+
+  constructor(cliRenderer: CliRenderer, config: EasiarrConfig, onBack: () => void) {
+    const { container: pageContainer, content: contentBox } = createPageLayout(cliRenderer, {
+      title: "Homepage Setup",
+      stepInfo: "Configure Dashboard",
+      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.pageContainer = pageContainer
+
+    this.initKeyHandler()
+    this.refreshContent()
+  }
+
+  private initKeyHandler(): void {
+    this.keyHandler = (key: KeyEvent) => {
+      if (key.name === "escape" || (key.name === "c" && key.ctrl)) {
+        if (this.currentStep === "menu") {
+          this.cleanup()
+        } else {
+          this.currentStep = "menu"
+          this.refreshContent()
+        }
+        return
+      }
+
+      if (this.currentStep === "menu") {
+        this.handleMenuKeys(key)
+      } else if (this.currentStep === "preview" || this.currentStep === "done") {
+        if (key.name === "return" || key.name === "escape") {
+          this.currentStep = "menu"
+          this.refreshContent()
+        }
+      }
+    }
+    this.cliRenderer.keyInput.on("keypress", this.keyHandler)
+  }
+
+  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: "📊 Generate Services",
+        description: "Create services.yaml with all enabled apps",
+        action: () => this.generateServices(),
+      },
+      {
+        name: "👁️  Preview Config",
+        description: "Preview generated services.yaml",
+        action: () => this.previewServices(),
+      },
+      {
+        name: "📋 Show Enabled Apps",
+        description: "List apps that will be added to Homepage",
+        action: () => this.showEnabledApps(),
+      },
+      {
+        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 generateServices(): Promise<void> {
+    this.currentStep = "generating"
+    this.results = [{ name: "services.yaml", status: "configuring" }]
+    this.refreshContent()
+
+    try {
+      const paths = await saveHomepageConfig(this.config)
+      this.results[0].status = "success"
+      this.results[0].message = `Saved to ${paths.services}`
+    } 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 previewServices(): Promise<void> {
+    this.previewContent = await generateServicesYaml(this.config)
+    this.currentStep = "preview"
+    this.refreshContent()
+  }
+
+  private showEnabledApps(): void {
+    const apps = this.config.apps.filter((a) => a.enabled && a.id !== "homepage")
+
+    this.results = apps.map((app) => {
+      const def = getApp(app.id)
+      const hasWidget = def?.homepage?.widget ? "📊" : "📌"
+      return {
+        name: `${hasWidget} ${def?.name || app.id}`,
+        status: "success" as const,
+        message: def?.description,
+      }
+    })
+
+    if (this.results.length === 0) {
+      this.results = [{ name: "No apps enabled", status: "skipped", message: "Enable apps first" }]
+    }
+
+    this.currentStep = "done"
+    this.refreshContent()
+  }
+
+  private refreshContent(): void {
+    this.contentBox.getChildren().forEach((child) => child.destroy())
+
+    if (this.currentStep === "menu") {
+      this.renderMenu()
+    } else if (this.currentStep === "preview") {
+      this.renderPreview()
+    } else {
+      this.renderResults()
+    }
+  }
+
+  private renderMenu(): void {
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "Configure Homepage dashboard with your enabled apps:\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 renderPreview(): void {
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "Preview: services.yaml\n",
+        fg: "#50fa7b",
+      })
+    )
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "─".repeat(40) + "\n",
+        fg: "#555555",
+      })
+    )
+
+    // Show preview (truncated)
+    const lines = this.previewContent.split("\n").slice(0, 30)
+    for (const line of lines) {
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: line + "\n",
+          fg: line.startsWith("#") ? "#6272a4" : line.endsWith(":") ? "#8be9fd" : "#f8f8f2",
+        })
+      )
+    }
+
+    if (this.previewContent.split("\n").length > 30) {
+      this.contentBox.add(
+        new TextRenderable(this.cliRenderer, {
+          content: "\n... (truncated)\n",
+          fg: "#6272a4",
+        })
+      )
+    }
+
+    this.contentBox.add(
+      new TextRenderable(this.cliRenderer, {
+        content: "\nPress Enter or Esc to go back",
+        fg: "#6272a4",
+      })
+    )
+  }
+
+  private renderResults(): void {
+    const headerText = this.currentStep === "done" ? "Results:\n\n" : "Generating...\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 }))
+    }
+
+    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

@@ -16,6 +16,7 @@ import { ProwlarrSetup } from "./ProwlarrSetup"
 import { QBittorrentSetup } from "./QBittorrentSetup"
 import { FullAutoSetup } from "./FullAutoSetup"
 import { MonitorDashboard } from "./MonitorDashboard"
+import { HomepageSetup } from "./HomepageSetup"
 
 export class MainMenu {
   private renderer: RenderContext
@@ -129,6 +130,10 @@ export class MainMenu {
           name: "📊 Monitor Dashboard",
           description: "Configure app health monitoring",
         },
+        {
+          name: "🏠 Homepage Setup",
+          description: "Generate Homepage dashboard config",
+        },
         { name: "❌ Exit", description: "Close easiarr" },
       ],
     })
@@ -227,7 +232,18 @@ export class MainMenu {
           this.container.add(monitor)
           break
         }
-        case 11:
+        case 11: {
+          // Homepage Setup
+          this.menu.blur()
+          this.page.visible = false
+          const homepageSetup = new HomepageSetup(this.renderer as CliRenderer, this.config, () => {
+            this.page.visible = true
+            this.menu.focus()
+          })
+          this.container.add(homepageSetup)
+          break
+        }
+        case 12:
           process.exit(0)
           break
       }

package/src/ui/screens/QuickSetup.ts

@@ -40,6 +40,8 @@ export class QuickSetup {
     "jellyfin",
     "jellyseerr",
     "flaresolverr",
+    "homepage",
+    "easiarr-status",
   ])
 
   private rootDir: string = `${homedir()}/media`

package/src/utils/env.ts

@@ -5,8 +5,31 @@
 
 import { existsSync, readFileSync } from "node:fs"
 import { writeFile, readFile } from "node:fs/promises"
+import { networkInterfaces } from "node:os"
 import { getComposePath } from "../config/manager"
 
+/**
+ * Get the local IP address of the Docker host
+ * Returns the first non-internal IPv4 address found
+ */
+export function getLocalIp(): string {
+  const nets = networkInterfaces()
+
+  for (const name of Object.keys(nets)) {
+    const interfaces = nets[name]
+    if (!interfaces) continue
+
+    for (const net of interfaces) {
+      // Skip internal (loopback) and non-IPv4 addresses
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address
+      }
+    }
+  }
+
+  return "localhost"
+}
+
 /**
  * Get the path to the .env file
  */

package/src/utils/update-checker.ts

@@ -0,0 +1,210 @@
+/**
+ * Update Checker
+ * Check GitHub releases for new easiarr versions
+ */
+
+import { VersionInfo } from "../VersionInfo"
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { homedir } from "node:os"
+
+const GITHUB_REPO = "muhammedaksam/easiarr"
+const CACHE_FILE = join(homedir(), ".easiarr", ".update-cache.json")
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000 // 24 hours
+
+export interface UpdateInfo {
+  currentVersion: string
+  latestVersion: string
+  updateAvailable: boolean
+  releaseUrl: string
+  releaseNotes?: string
+  publishedAt?: string
+}
+
+interface CachedUpdate {
+  checkedAt: string
+  latestVersion: string
+  releaseUrl: string
+  releaseNotes?: string
+  publishedAt?: string
+}
+
+/**
+ * Get cached update info if still valid
+ */
+function getCachedUpdate(): CachedUpdate | null {
+  if (!existsSync(CACHE_FILE)) return null
+
+  try {
+    const content = readFileSync(CACHE_FILE, "utf-8")
+    const cached = JSON.parse(content) as CachedUpdate
+
+    const checkedAt = new Date(cached.checkedAt).getTime()
+    const now = Date.now()
+
+    // Cache still valid
+    if (now - checkedAt < CACHE_DURATION_MS) {
+      return cached
+    }
+  } catch {
+    // Ignore cache errors
+  }
+
+  return null
+}
+
+/**
+ * Save update info to cache
+ */
+function cacheUpdate(info: Omit<CachedUpdate, "checkedAt">): void {
+  try {
+    const cached: CachedUpdate = {
+      ...info,
+      checkedAt: new Date().toISOString(),
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(cached, null, 2), "utf-8")
+  } catch {
+    // Ignore cache write errors
+  }
+}
+
+/**
+ * Compare semver versions
+ * Returns true if v2 is newer than v1
+ */
+function isNewerVersion(v1: string, v2: string): boolean {
+  const normalize = (v: string) => v.replace(/^v/, "")
+  const parts1 = normalize(v1).split(".").map(Number)
+  const parts2 = normalize(v2).split(".").map(Number)
+
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0
+    const p2 = parts2[i] || 0
+    if (p2 > p1) return true
+    if (p2 < p1) return false
+  }
+
+  return false
+}
+
+/**
+ * Fetch latest release from GitHub API
+ */
+async function fetchLatestRelease(): Promise<{
+  version: string
+  url: string
+  notes?: string
+  publishedAt?: string
+} | null> {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "easiarr-update-checker",
+      },
+    })
+
+    if (!response.ok) {
+      return null
+    }
+
+    const data = (await response.json()) as {
+      tag_name: string
+      html_url: string
+      body?: string
+      published_at?: string
+    }
+
+    return {
+      version: data.tag_name,
+      url: data.html_url,
+      notes: data.body,
+      publishedAt: data.published_at,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Check for updates
+ * Uses cache to avoid repeated API calls
+ */
+export async function checkForUpdates(): Promise<UpdateInfo> {
+  const currentVersion = VersionInfo.version
+
+  // Check cache first
+  const cached = getCachedUpdate()
+  if (cached) {
+    return {
+      currentVersion,
+      latestVersion: cached.latestVersion,
+      updateAvailable: isNewerVersion(currentVersion, cached.latestVersion),
+      releaseUrl: cached.releaseUrl,
+      releaseNotes: cached.releaseNotes,
+      publishedAt: cached.publishedAt,
+    }
+  }
+
+  // Fetch from GitHub
+  const release = await fetchLatestRelease()
+
+  if (!release) {
+    return {
+      currentVersion,
+      latestVersion: currentVersion,
+      updateAvailable: false,
+      releaseUrl: `https://github.com/${GITHUB_REPO}/releases`,
+    }
+  }
+
+  // Cache the result
+  cacheUpdate({
+    latestVersion: release.version,
+    releaseUrl: release.url,
+    releaseNotes: release.notes,
+    publishedAt: release.publishedAt,
+  })
+
+  return {
+    currentVersion,
+    latestVersion: release.version,
+    updateAvailable: isNewerVersion(currentVersion, release.version),
+    releaseUrl: release.url,
+    releaseNotes: release.notes,
+    publishedAt: release.publishedAt,
+  }
+}
+
+/**
+ * Force refresh update check (ignores cache)
+ */
+export async function forceCheckForUpdates(): Promise<UpdateInfo> {
+  const currentVersion = VersionInfo.version
+  const release = await fetchLatestRelease()
+
+  if (!release) {
+    return {
+      currentVersion,
+      latestVersion: currentVersion,
+      updateAvailable: false,
+      releaseUrl: `https://github.com/${GITHUB_REPO}/releases`,
+    }
+  }
+
+  cacheUpdate({
+    latestVersion: release.version,
+    releaseUrl: release.url,
+    releaseNotes: release.notes,
+    publishedAt: release.publishedAt,
+  })
+
+  return {
+    currentVersion,
+    latestVersion: release.version,
+    updateAvailable: isNewerVersion(currentVersion, release.version),
+    releaseUrl: release.url,
+    releaseNotes: release.notes,
+    publishedAt: release.publishedAt,
+  }
+}