@muhammedaksam/easiarr 0.1.1 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammedaksam/easiarr",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "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: {
@@ -866,3 +870,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 {

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