@muhammedaksam/easiarr 1.3.5 → 1.4.1

package/src/utils/migrations.ts

@@ -1,164 +0,0 @@
-/**
- * Migration Runner
- * Sequelize-style migrations with Unix timestamp naming
- *
- * Migration files: src/utils/migrations/{timestamp}_{name}.ts
- * Each migration exports: name, up()
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import { homedir } from "node:os"
-import { debugLog } from "./debug"
-
-/**
- * Get the XDG config directory for easiarr
- */
-function getXdgConfigDir(): string {
-  const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
-  return join(xdgConfigHome, "easiarr")
-}
-
-const EASIARR_DIR = getXdgConfigDir()
-const MIGRATIONS_FILE = join(EASIARR_DIR, ".migrations.json")
-
-interface MigrationState {
-  applied: string[] // List of applied migration timestamps
-  lastRun: string
-}
-
-interface Migration {
-  timestamp: string
-  name: string
-  up: () => boolean
-  down: () => boolean
-}
-
-/**
- * Ensure the easiarr directory exists
- */
-function ensureEasiarrDir(): void {
-  if (!existsSync(EASIARR_DIR)) {
-    mkdirSync(EASIARR_DIR, { recursive: true })
-  }
-}
-
-/**
- * Get the current migration state
- */
-function getMigrationState(): MigrationState {
-  if (!existsSync(MIGRATIONS_FILE)) {
-    return { applied: [], lastRun: "" }
-  }
-
-  try {
-    const content = readFileSync(MIGRATIONS_FILE, "utf-8")
-    return JSON.parse(content) as MigrationState
-  } catch {
-    return { applied: [], lastRun: "" }
-  }
-}
-
-/**
- * Save the migration state
- */
-function saveMigrationState(state: MigrationState): void {
-  ensureEasiarrDir()
-  state.lastRun = new Date().toISOString()
-  writeFileSync(MIGRATIONS_FILE, JSON.stringify(state, null, 2), "utf-8")
-}
-
-/**
- * Load all migration modules
- */
-async function loadMigrations(): Promise<Migration[]> {
-  const migrations: Migration[] = []
-
-  // Import migrations directly - bundled at build time
-  try {
-    const m1 = await import("./migrations/1765626338_rename_env_variables")
-    migrations.push({
-      timestamp: "1765626338",
-      name: m1.name,
-      up: m1.up,
-      down: m1.down,
-    })
-  } catch (e) {
-    debugLog("Migrations", `Failed to load migration: ${e}`)
-  }
-
-  try {
-    const m1765707135 = await import("./migrations/1765707135_rename_easiarr_status")
-    migrations.push({
-      timestamp: "1765707135",
-      name: m1765707135.name,
-      up: m1765707135.up,
-      down: m1765707135.down,
-    })
-  } catch (e) {
-    debugLog("Migrations", `Failed to load migration: ${e}`)
-  }
-
-  try {
-    const m1765732722 = await import("./migrations/1765732722_remove_cloudflare_dns_api_token")
-    migrations.push({
-      timestamp: "1765732722",
-      name: m1765732722.name,
-      up: m1765732722.up,
-      down: m1765732722.down,
-    })
-  } catch (e) {
-    debugLog("Migrations", `Failed to load migration: ${e}`)
-  }
-
-  try {
-    const m1769515650 = await import("./migrations/1769515650_migrate_to_xdg")
-    migrations.push({
-      timestamp: "1769515650",
-      name: m1769515650.name,
-      up: m1769515650.up,
-      down: m1769515650.down,
-    })
-  } catch (e) {
-    debugLog("Migrations", `Failed to load migration: ${e}`)
-  }
-
-  // Add future migrations here:
-  // const m2 = await import("./migrations/1734xxxxxx_xxx")
-  // migrations.push({ timestamp: "...", name: m2.name, up: m2.up })
-
-  return migrations.sort((a, b) => a.timestamp.localeCompare(b.timestamp))
-}
-
-/**
- * Run all pending migrations
- */
-export async function runMigrations(): Promise<void> {
-  const state = getMigrationState()
-  const migrations = await loadMigrations()
-
-  let hasChanges = false
-
-  for (const migration of migrations) {
-    if (state.applied.includes(migration.timestamp)) {
-      continue
-    }
-
-    debugLog("Migrations", `Running migration ${migration.timestamp}_${migration.name}`)
-
-    try {
-      migration.up()
-      state.applied.push(migration.timestamp)
-      hasChanges = true
-      debugLog("Migrations", `Migration ${migration.timestamp} completed`)
-    } catch (e) {
-      debugLog("Migrations", `Migration ${migration.timestamp} failed: ${e}`)
-    }
-  }
-
-  if (hasChanges) {
-    saveMigrationState(state)
-  } else {
-    debugLog("Migrations", "No pending migrations")
-  }
-}

package/src/utils/password.ts

@@ -1,42 +0,0 @@
-/**
- * Password Utilities
- * Helpers for password validation and transformation
- */
-
-/**
- * Ensures a password meets minimum length requirements by repeating it.
- * If the password is already long enough, returns it unchanged.
- *
- * @param password - The original password
- * @param minLength - Minimum required length
- * @returns Password padded to at least minLength characters
- */
-export function ensureMinPasswordLength(password: string, minLength: number): string {
-  if (!password || password.length === 0) {
-    throw new Error("Password cannot be empty")
-  }
-
-  if (password.length >= minLength) {
-    return password
-  }
-
-  // Repeat the password until it meets minimum length
-  let extendedPassword = password
-  while (extendedPassword.length < minLength) {
-    extendedPassword += password
-  }
-
-  // Return exactly minLength characters
-  return extendedPassword.slice(0, minLength)
-}
-
-/**
- * Validates if a password meets minimum length requirements.
- *
- * @param password - The password to validate
- * @param minLength - Minimum required length
- * @returns true if password meets requirements
- */
-export function isPasswordValid(password: string, minLength: number): boolean {
-  return password !== undefined && password !== null && password.length >= minLength
-}

package/src/utils/unraid.ts

@@ -1,101 +0,0 @@
-/**
- * Unraid Detection and Compatibility Utilities
- * Provides detection of Unraid environment and path adjustments
- */
-
-import { existsSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import { debugLog } from "./debug"
-
-// Unraid-specific paths
-const UNRAID_IDENTIFIERS = [
-  "/boot/config/plugins", // Unraid plugin directory
-  "/etc/unraid-version", // Unraid version file
-  "/var/local/emhttp", // Unraid emhttp directory
-]
-
-const UNRAID_APPDATA_PATH = "/mnt/user/appdata"
-const COMPOSE_MANAGER_PLUGIN_PATH = "/boot/config/plugins/compose.manager"
-
-/**
- * Detect if running on Unraid OS
- * Checks for Unraid-specific filesystem paths
- */
-export function isUnraid(): boolean {
-  for (const path of UNRAID_IDENTIFIERS) {
-    if (existsSync(path)) {
-      debugLog("Unraid", `Detected Unraid OS (found ${path})`)
-      return true
-    }
-  }
-  return false
-}
-
-/**
- * Get the default appdata path for Unraid
- * Returns /mnt/user/appdata/easiarr on Unraid, ~/.easiarr otherwise
- */
-export function getUnraidAppDataPath(): string {
-  if (isUnraid()) {
-    return join(UNRAID_APPDATA_PATH, "easiarr")
-  }
-  return join(homedir(), ".easiarr")
-}
-
-/**
- * Check if Docker Compose Manager plugin is installed
- * This plugin allows managing compose stacks via Unraid's web UI
- */
-export function hasComposeManager(): boolean {
-  return existsSync(COMPOSE_MANAGER_PLUGIN_PATH)
-}
-
-/**
- * Get the recommended Compose Manager project directory
- * Compose Manager expects projects in /boot/config/plugins/compose.manager/projects/
- */
-export function getComposeManagerProjectPath(projectName: string = "easiarr"): string {
-  return join(COMPOSE_MANAGER_PLUGIN_PATH, "projects", projectName)
-}
-
-/**
- * Get platform-appropriate default root directory
- * Adjusts paths for Unraid vs standard Linux/Mac
- */
-export function getDefaultRootDir(): string {
-  if (isUnraid()) {
-    // On Unraid, use /mnt/user/data for media and /mnt/user/appdata for configs
-    return "/mnt/user/data"
-  }
-  // Standard path
-  return join(homedir(), "easiarr")
-}
-
-/**
- * Get platform-appropriate config directory
- */
-export function getConfigDir(): string {
-  if (isUnraid()) {
-    return UNRAID_APPDATA_PATH
-  }
-  return join(homedir(), ".easiarr")
-}
-
-/**
- * Get Unraid-specific information for display
- */
-export function getUnraidInfo(): {
-  isUnraid: boolean
-  hasComposeManager: boolean
-  appDataPath: string
-  composeManagerPath: string | null
-} {
-  const onUnraid = isUnraid()
-  return {
-    isUnraid: onUnraid,
-    hasComposeManager: onUnraid ? hasComposeManager() : false,
-    appDataPath: onUnraid ? UNRAID_APPDATA_PATH : join(homedir(), ".easiarr"),
-    composeManagerPath: onUnraid && hasComposeManager() ? getComposeManagerProjectPath() : null,
-  }
-}

package/src/utils/update-checker.ts

@@ -1,210 +0,0 @@
-/**
- * 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,
-  }
-}

package/src/utils/url-utils.ts

@@ -1,38 +0,0 @@
-/**
- * URL Utilities
- * Functions for generating app URLs based on Traefik configuration
- */
-
-import type { EasiarrConfig } from "../config/schema"
-import { getLocalIp } from "./env"
-
-/**
- * Get the local URL for an app (http://LOCAL_IP:PORT)
- */
-export function getLocalAppUrl(port: number): string {
-  const localIp = getLocalIp()
-  return `http://${localIp}:${port}`
-}
-
-/**
- * Get the external URL for an app (https://APP.DOMAIN)
- * Returns null if Traefik is not enabled
- */
-export function getExternalAppUrl(appId: string, config: EasiarrConfig): string | null {
-  if (!config.traefik?.enabled || !config.traefik.domain) {
-    return null
-  }
-  return `https://${appId}.${config.traefik.domain}`
-}
-
-/**
- * Get the appropriate applicationUrl based on Traefik status
- * Returns external URL if Traefik enabled, otherwise local URL
- */
-export function getApplicationUrl(appId: string, port: number, config: EasiarrConfig): string {
-  const externalUrl = getExternalAppUrl(appId, config)
-  if (externalUrl) {
-    return externalUrl
-  }
-  return getLocalAppUrl(port)
-}