@muhammedaksam/easiarr 0.1.0

package/src/compose/generator.ts

@@ -0,0 +1,234 @@
+/**
+ * Docker Compose Generator
+ * Generates docker-compose.yml from Easiarr configuration
+ */
+
+import { writeFile, readFile } from "node:fs/promises"
+import { existsSync } from "node:fs"
+import type { EasiarrConfig, AppConfig, TraefikConfig, AppId } from "../config/schema"
+import { getComposePath } from "../config/manager"
+import { getApp } from "../apps/registry"
+import { generateServiceYaml } from "./templates"
+
+export interface ComposeService {
+  image: string
+  container_name: string
+  environment: Record<string, string | number>
+  volumes: string[]
+  ports: string[]
+  restart: string
+  depends_on?: string[]
+  network_mode?: string
+  labels?: string[]
+  devices?: string[]
+  cap_add?: string[]
+}
+
+export interface ComposeFile {
+  services: Record<string, ComposeService>
+}
+
+export function generateCompose(config: EasiarrConfig): string {
+  const services: Record<string, ComposeService> = {}
+
+  // Track ports to move to Gluetun
+  const gluetunPorts: string[] = []
+  // Track routing decisions
+  const routedApps = new Set<string>()
+
+  // 1. Build all services first
+  for (const appConfig of config.apps) {
+    if (!appConfig.enabled) continue
+
+    const appDef = getApp(appConfig.id)
+    if (!appDef) continue
+
+    const service = buildService(appDef, appConfig, config)
+    services[appConfig.id] = service
+  }
+
+  // 2. Apply VPN routing if enabled
+  if (config.vpn && config.vpn.mode !== "none" && services["gluetun"]) {
+    const vpnMode = config.vpn.mode
+
+    for (const [id, service] of Object.entries(services)) {
+      if (id === "gluetun") continue
+
+      const appDef = getApp(id as AppId)
+      if (!appDef) continue
+
+      // Determine if app should be routed
+      let shouldRoute = false
+
+      // Mini: Downloaders only
+      if (vpnMode === "mini" && appDef.category === "downloader") {
+        shouldRoute = true
+      }
+      // Full: Downloaders, Indexers, Requests, MediaServers, Servarr
+      else if (
+        vpnMode === "full" &&
+        ["downloader", "indexer", "request", "mediaserver", "servarr"].includes(appDef.category)
+      ) {
+        shouldRoute = true
+      }
+
+      if (shouldRoute) {
+        // Move ports to Gluetun
+        if (service.ports && service.ports.length > 0) {
+          gluetunPorts.push(...service.ports)
+          service.ports = []
+        }
+
+        // Set network mode
+        service.network_mode = "service:gluetun"
+        routedApps.add(id)
+
+        // Remove depends_on gluetun if it exists (circular check, though service:gluetun implies dependency)
+        // Actually docker-compose handles implied dependency for network_mode: service:xxx
+      }
+    }
+
+    // 3. Add ports to Gluetun
+    if (gluetunPorts.length > 0) {
+      services["gluetun"].ports = [...new Set([...(services["gluetun"].ports || []), ...gluetunPorts])]
+    }
+  }
+
+  return formatComposeYaml({ services })
+}
+
+function buildService(appDef: ReturnType<typeof getApp>, appConfig: AppConfig, config: EasiarrConfig): ComposeService {
+  if (!appDef) throw new Error("App definition not found")
+
+  const port = appConfig.port ?? appDef.defaultPort
+  // Use ${ROOT_DIR} for volumes
+  const volumes = [...appDef.volumes("${ROOT_DIR}"), ...(appConfig.customVolumes ?? [])]
+
+  // Build environment
+  const environment: Record<string, string | number> = {
+    TZ: "${TIMEZONE}",
+  }
+
+  // Add PUID/PGID (Use globals)
+  if (appDef.puid > 0 || appDef.pgid > 0 || ["jellyfin", "tautulli"].includes(appDef.id)) {
+    environment.PUID = "${PUID}"
+    environment.PGID = "${PGID}"
+    environment.UMASK = "${UMASK}"
+  }
+
+  // Add app-specific environment
+  if (appDef.environment) {
+    Object.assign(environment, appDef.environment)
+  }
+
+  // Add custom environment from config
+  if (appConfig.customEnv) {
+    Object.assign(environment, appConfig.customEnv)
+  }
+
+  const service: ComposeService = {
+    image: appDef.image,
+    container_name: appDef.id,
+    environment,
+    volumes,
+    ports: appDef.id === "plex" ? [] : [`"${port}:${appDef.defaultPort}"`],
+    restart: "unless-stopped",
+  }
+
+  // Add devices/caps
+  if (appDef.devices) service.devices = [...appDef.devices]
+  if (appDef.cap_add) service.cap_add = [...appDef.cap_add]
+
+  // Plex uses network_mode: host
+  if (appDef.id === "plex") {
+    service.network_mode = "host"
+  }
+
+  // Add dependencies
+  if (appDef.dependsOn && appDef.dependsOn.length > 0) {
+    const enabledDeps = appDef.dependsOn.filter((dep) => config.apps.some((a) => a.id === dep && a.enabled))
+    if (enabledDeps.length > 0) {
+      service.depends_on = enabledDeps
+    }
+  }
+
+  // Add Traefik labels if enabled (skip for traefik itself and plex with host networking)
+  if (config.traefik?.enabled && appDef.id !== "traefik" && appDef.id !== "plex") {
+    service.labels = generateTraefikLabels(appDef.id, appDef.defaultPort, config.traefik)
+  }
+
+  return service
+}
+
+function generateTraefikLabels(serviceName: string, port: number, traefik: TraefikConfig): string[] {
+  const labels: string[] = [
+    "traefik.enable=true",
+    // Router
+    `traefik.http.routers.${serviceName}.service=${serviceName}`,
+    `traefik.http.routers.${serviceName}.rule=Host(\`${serviceName}.${traefik.domain}\`)`,
+    `traefik.http.routers.${serviceName}.entrypoints=${traefik.entrypoint}`,
+  ]
+
+  // Add middlewares if configured
+  if (traefik.middlewares.length > 0) {
+    labels.push(`traefik.http.routers.${serviceName}.middlewares=${traefik.middlewares.join(",")}`)
+  }
+
+  // Service/Load balancer
+  labels.push(
+    `traefik.http.services.${serviceName}.loadbalancer.server.scheme=http`,
+    `traefik.http.services.${serviceName}.loadbalancer.server.port=${port}`
+  )
+
+  return labels
+}
+
+function formatComposeYaml(compose: ComposeFile): string {
+  let yaml = "---\nservices:\n"
+
+  for (const [name, service] of Object.entries(compose.services)) {
+    yaml += generateServiceYaml(name, service)
+  }
+
+  return yaml
+}
+
+export async function saveCompose(config: EasiarrConfig): Promise<string> {
+  const yaml = generateCompose(config)
+  const path = getComposePath()
+  await writeFile(path, yaml, "utf-8")
+
+  // Update .env
+  await updateEnvFile(config)
+
+  return path
+}
+
+async function updateEnvFile(config: EasiarrConfig) {
+  const envPath = getComposePath().replace("docker-compose.yml", ".env")
+  let envContent = ""
+
+  // Read existing .env if present to preserve secrets
+  const currentEnv: Record<string, string> = {}
+  if (existsSync(envPath)) {
+    const content = await readFile(envPath, "utf-8")
+    content.split("\n").forEach((line) => {
+      const [key, ...val] = line.split("=")
+      if (key && val) currentEnv[key.trim()] = val.join("=").trim()
+    })
+  }
+
+  // Update/Set globals
+  currentEnv["ROOT_DIR"] = config.rootDir
+  currentEnv["TIMEZONE"] = config.timezone
+  currentEnv["PUID"] = config.uid.toString()
+  currentEnv["PGID"] = config.gid.toString()
+  currentEnv["UMASK"] = config.umask
+
+  // Reconstruct .env content
+  envContent = Object.entries(currentEnv)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n")
+
+  await writeFile(envPath, envContent, "utf-8")
+}

package/src/compose/index.ts

@@ -0,0 +1,2 @@
+export * from "./generator"
+export * from "./templates"

package/src/compose/templates.ts

@@ -0,0 +1,68 @@
+/**
+ * Docker Compose YAML Templates
+ * Generates properly formatted YAML for services
+ */
+
+import type { ComposeService } from "./generator"
+
+export function generateServiceYaml(name: string, service: ComposeService): string {
+  let yaml = `  ${name}:\n`
+  yaml += `    image: ${service.image}\n`
+  yaml += `    container_name: ${service.container_name}\n`
+
+  // Network mode (for Plex)
+  if (service.network_mode) {
+    yaml += `    network_mode: ${service.network_mode}\n`
+  }
+
+  // Dependencies
+  if (service.depends_on && service.depends_on.length > 0) {
+    yaml += `    depends_on:\n`
+    for (const dep of service.depends_on) {
+      yaml += `      - ${dep}\n`
+    }
+  }
+
+  // Environment
+  if (Object.keys(service.environment).length > 0) {
+    yaml += `    environment:\n`
+    for (const [key, value] of Object.entries(service.environment)) {
+      yaml += `      - ${key}=${value}\n`
+    }
+  }
+
+  // Volumes
+  if (service.volumes.length > 0) {
+    yaml += `    volumes:\n`
+    for (const volume of service.volumes) {
+      yaml += `      - ${volume}\n`
+    }
+  }
+
+  // Ports (skip for network_mode: host)
+  if (service.ports.length > 0 && !service.network_mode) {
+    yaml += `    ports:\n`
+    for (const port of service.ports) {
+      yaml += `      - ${port}\n`
+    }
+  }
+
+  // Labels (for Traefik etc.)
+  if (service.labels && service.labels.length > 0) {
+    yaml += `    labels:\n`
+    for (const label of service.labels) {
+      yaml += `      - ${label}\n`
+    }
+  }
+
+  yaml += `    restart: ${service.restart}\n\n`
+
+  return yaml
+}
+
+export function generateNetworkYaml(name: string, driver: string): string {
+  return `networks:
+  ${name}:
+    driver: ${driver}
+`
+}

package/src/config/defaults.ts

@@ -0,0 +1,37 @@
+/**
+ * Default Value Detection
+ * Auto-detect timezone and UID/GID from system
+ */
+
+import { readlinkSync, existsSync } from "node:fs"
+
+export function detectTimezone(): string {
+  const tzPath = "/etc/localtime"
+
+  if (existsSync(tzPath)) {
+    try {
+      const link = readlinkSync(tzPath)
+      const parts = link.split("zoneinfo/")
+      if (parts.length > 1) {
+        return parts[1]
+      }
+    } catch {
+      // Fallback if not a symlink
+    }
+  }
+
+  // Try TZ environment variable
+  if (process.env.TZ) {
+    return process.env.TZ
+  }
+
+  return "UTC"
+}
+
+export function detectUid(): number {
+  return process.getuid?.() ?? 1000
+}
+
+export function detectGid(): number {
+  return process.getgid?.() ?? 1000
+}

package/src/config/index.ts

@@ -0,0 +1,3 @@
+export * from "./schema"
+export * from "./manager"
+export * from "./defaults"

package/src/config/manager.ts

@@ -0,0 +1,109 @@
+/**
+ * Configuration Manager
+ * Handles reading and writing config to ~/.easiarr/
+ */
+
+import { mkdir, readFile, writeFile, copyFile } from "node:fs/promises"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import type { EasiarrConfig } from "./schema"
+import { DEFAULT_CONFIG } from "./schema"
+import { detectTimezone, detectUid, detectGid } from "./defaults"
+
+const CONFIG_DIR_NAME = ".easiarr"
+const CONFIG_FILE_NAME = "config.json"
+const BACKUP_DIR_NAME = "backups"
+
+export function getConfigDir(): string {
+  return join(homedir(), CONFIG_DIR_NAME)
+}
+
+export function getConfigPath(): string {
+  return join(getConfigDir(), CONFIG_FILE_NAME)
+}
+
+export function getBackupDir(): string {
+  return join(getConfigDir(), BACKUP_DIR_NAME)
+}
+
+export function getComposePath(): string {
+  return join(getConfigDir(), "docker-compose.yml")
+}
+
+export async function ensureConfigDir(): Promise<void> {
+  const configDir = getConfigDir()
+  const backupDir = getBackupDir()
+
+  if (!existsSync(configDir)) {
+    await mkdir(configDir, { recursive: true })
+  }
+
+  if (!existsSync(backupDir)) {
+    await mkdir(backupDir, { recursive: true })
+  }
+}
+
+export async function configExists(): Promise<boolean> {
+  return existsSync(getConfigPath())
+}
+
+export async function loadConfig(): Promise<EasiarrConfig | null> {
+  const configPath = getConfigPath()
+
+  if (!existsSync(configPath)) {
+    return null
+  }
+
+  try {
+    const content = await readFile(configPath, "utf-8")
+    return JSON.parse(content) as EasiarrConfig
+  } catch (error) {
+    console.error("Failed to load config:", error)
+    return null
+  }
+}
+
+export async function saveConfig(config: EasiarrConfig): Promise<void> {
+  await ensureConfigDir()
+
+  const configPath = getConfigPath()
+
+  // Create backup if config already exists
+  if (existsSync(configPath)) {
+    await backupConfig()
+  }
+
+  // Update timestamp
+  config.updatedAt = new Date().toISOString()
+
+  await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8")
+}
+
+export async function backupConfig(): Promise<void> {
+  const configPath = getConfigPath()
+
+  if (!existsSync(configPath)) {
+    return
+  }
+
+  const backupDir = getBackupDir()
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupPath = join(backupDir, `config-${timestamp}.json`)
+
+  await copyFile(configPath, backupPath)
+}
+
+export function createDefaultConfig(rootDir: string): EasiarrConfig {
+  const now = new Date().toISOString()
+
+  return {
+    ...DEFAULT_CONFIG,
+    rootDir,
+    timezone: detectTimezone(),
+    uid: detectUid(),
+    gid: detectGid(),
+    createdAt: now,
+    updatedAt: now,
+  }
+}

package/src/config/schema.ts

@@ -0,0 +1,191 @@
+/**
+ * Easiarr Configuration Schema
+ * TypeScript interfaces for configuration management
+ */
+
+import { VersionInfo } from "../VersionInfo"
+
+export interface EasiarrConfig {
+  version: string
+  rootDir: string
+  timezone: string
+  uid: number
+  gid: number
+  umask: string
+  apps: AppConfig[]
+  network?: NetworkConfig
+  traefik?: TraefikConfig
+  vpn?: VpnConfig
+  createdAt: string
+  updatedAt: string
+}
+
+export type VpnMode = "full" | "mini" | "none"
+
+export interface VpnConfig {
+  mode: VpnMode
+  provider?: string // For future use (e.g. custom, airvpn, protonvpn)
+}
+
+export interface TraefikConfig {
+  enabled: boolean
+  domain: string
+  entrypoint: string
+  middlewares: string[]
+}
+
+export interface AppConfig {
+  id: AppId
+  enabled: boolean
+  port?: number
+  customEnv?: Record<string, string>
+  customVolumes?: string[]
+  labels?: string[]
+  devices?: string[]
+  cap_add?: string[]
+}
+
+export interface NetworkConfig {
+  name: string
+  driver: "bridge" | "host" | "none"
+}
+
+export type AppId =
+  // Media Management (Servarr)
+  | "radarr"
+  | "sonarr"
+  | "lidarr"
+  | "readarr"
+  | "bazarr"
+  | "mylar3"
+  | "whisparr"
+  | "audiobookshelf"
+  // Indexers
+  | "prowlarr"
+  | "jackett"
+  | "flaresolverr"
+  // Download Clients
+  | "qbittorrent"
+  | "sabnzbd"
+  // Media Servers
+  | "plex"
+  | "jellyfin"
+  | "tautulli"
+  | "tdarr"
+  // Request Management
+  | "overseerr"
+  | "jellyseerr"
+  // Dashboards
+  | "homarr"
+  | "heimdall"
+  | "homepage"
+  // Utilities
+  | "huntarr"
+  | "unpackerr"
+  | "filebot"
+  | "chromium"
+  | "guacamole"
+  | "guacd"
+  | "ddns-updater"
+  // VPN
+  | "gluetun"
+  // Monitoring & Infra
+  | "portainer"
+  | "dozzle"
+  | "uptime-kuma"
+  // Monitoring
+  | "grafana"
+  | "prometheus"
+  // Reverse Proxy
+  | "traefik"
+  | "traefik-certs-dumper"
+  | "crowdsec"
+  // Network/VPN
+  | "headscale"
+  | "headplane"
+  | "tailscale"
+  // Authentication
+  | "authentik"
+  | "authentik-worker"
+  // Database
+  | "postgresql"
+  | "valkey"
+
+export type AppCategory =
+  | "servarr"
+  | "indexer"
+  | "downloader"
+  | "mediaserver"
+  | "request"
+  | "dashboard"
+  | "utility"
+  | "vpn"
+  | "monitoring"
+  | "infrastructure"
+
+export interface AppDefinition {
+  id: AppId
+  name: string
+  description: string
+  category: AppCategory
+  defaultPort: number
+  image: string
+  puid: number
+  pgid: number
+  volumes: (rootDir: string) => string[]
+  environment?: Record<string, string>
+  dependsOn?: AppId[]
+  trashGuide?: string
+  secrets?: AppSecret[]
+  devices?: string[]
+  cap_add?: string[]
+  apiKeyMeta?: ApiKeyMeta
+  rootFolder?: RootFolderMeta
+}
+
+export interface RootFolderMeta {
+  path: string // e.g. "/data/media/movies"
+  apiVersion: "v1" | "v3"
+}
+
+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
+  description?: string
+  transform?: (value: string) => string
+}
+
+export type ApiKeyParserType = "xml" | "ini" | "json" | "regex"
+
+export interface AppSecret {
+  name: string
+  description: string
+  required: boolean
+  default?: string
+  generate?: boolean // Suggest auto-generation
+  mask?: boolean // Mask input
+}
+
+export const APP_CATEGORIES: Record<AppCategory, string> = {
+  servarr: "Media Management",
+  indexer: "Indexers",
+  downloader: "Download Clients",
+  mediaserver: "Media Servers",
+  request: "Request Management",
+  dashboard: "Dashboards",
+  utility: "Utilities",
+  vpn: "VPN",
+  monitoring: "Monitoring",
+  infrastructure: "Infrastructure",
+}
+
+export const DEFAULT_CONFIG: Omit<EasiarrConfig, "createdAt" | "updatedAt"> = {
+  version: VersionInfo.version,
+  rootDir: "",
+  timezone: "",
+  uid: 1000,
+  gid: 1000,
+  umask: "002",
+  apps: [],
+}