@muhammedaksam/easiarr 0.1.10 → 0.3.0

package/package.json

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

@@ -12,6 +12,13 @@ export interface RootFolder {
   unmappedFolders?: { name: string | null; path: string | null; relativePath: string | null }[]
 }
 
+// Options for adding root folder (some apps like Lidarr need extra fields)
+export interface AddRootFolderOptions {
+  path: string
+  defaultMetadataProfileId?: number
+  defaultQualityProfileId?: number
+}
+
 // Types for Download Client API
 export interface DownloadClientConfig {
   name: string
@@ -26,42 +33,16 @@ export interface DownloadClient extends DownloadClientConfig {
   id?: number
 }
 
-import type { AppId } from "../config/schema"
-
-// Get category name for an app
-function getCategoryForApp(appId: AppId): string {
-  switch (appId) {
-    case "radarr":
-      return "movies"
-    case "sonarr":
-      return "tv"
-    case "lidarr":
-      return "music"
-    case "readarr":
-      return "books"
-    case "whisparr":
-      return "adult"
-    default:
-      return "default"
-  }
+// Types for Remote Path Mapping API
+export interface RemotePathMapping {
+  id?: number
+  host: string
+  remotePath: string
+  localPath: string
 }
 
-// Get category field name for an app (different apps use different field names)
-function getCategoryFieldName(appId: AppId): string {
-  switch (appId) {
-    case "radarr":
-      return "movieCategory"
-    case "sonarr":
-    case "whisparr":
-      return "tvCategory"
-    case "lidarr":
-      return "musicCategory"
-    case "readarr":
-      return "bookCategory"
-    default:
-      return "category"
-  }
-}
+import type { AppId } from "../config/schema"
+import { getCategoryForApp, getCategoryFieldName } from "../utils/categories"
 
 // qBittorrent download client config
 export function createQBittorrentConfig(
@@ -161,13 +142,31 @@ export class ArrApiClient {
     return this.request<RootFolder[]>("/rootfolder")
   }
 
-  async addRootFolder(path: string): Promise<RootFolder> {
+  async addRootFolder(pathOrOptions: string | AddRootFolderOptions): Promise<RootFolder> {
+    const body = typeof pathOrOptions === "string" ? { path: pathOrOptions } : pathOrOptions
     return this.request<RootFolder>("/rootfolder", {
       method: "POST",
-      body: JSON.stringify({ path }),
+      body: JSON.stringify(body),
     })
   }
 
+  // Profile methods (needed for Lidarr root folders)
+  async getMetadataProfiles(): Promise<{ id: number; name: string }[]> {
+    try {
+      return await this.request<{ id: number; name: string }[]>("/metadataprofile")
+    } catch {
+      return []
+    }
+  }
+
+  async getQualityProfiles(): Promise<{ id: number; name: string }[]> {
+    try {
+      return await this.request<{ id: number; name: string }[]>("/qualityprofile")
+    } catch {
+      return []
+    }
+  }
+
   async deleteRootFolder(id: number): Promise<void> {
     await this.request(`/rootfolder/${id}`, { method: "DELETE" })
   }
@@ -228,6 +227,22 @@ export class ArrApiClient {
       body: JSON.stringify(updatedConfig),
     })
   }
+
+  // Remote Path Mapping methods - for Docker path translation
+  async getRemotePathMappings(): Promise<RemotePathMapping[]> {
+    return this.request<RemotePathMapping[]>("/remotepathmapping")
+  }
+
+  async addRemotePathMapping(host: string, remotePath: string, localPath: string): Promise<RemotePathMapping> {
+    return this.request<RemotePathMapping>("/remotepathmapping", {
+      method: "POST",
+      body: JSON.stringify({ host, remotePath, localPath }),
+    })
+  }
+
+  async deleteRemotePathMapping(id: number): Promise<void> {
+    await this.request(`/remotepathmapping/${id}`, { method: "DELETE" })
+  }
 }
 
 // Types for Host Config API

package/src/api/custom-format-api.ts

@@ -0,0 +1,212 @@
+/**
+ * Custom Format API Client
+ * Manages Custom Formats for Radarr/Sonarr with TRaSH Guides import capability
+ */
+
+export interface CFSpecification {
+  name: string
+  implementation: string
+  negate: boolean
+  required: boolean
+  fields: { name: string; value: unknown }[]
+}
+
+export interface CustomFormat {
+  id?: number
+  name: string
+  includeCustomFormatWhenRenaming: boolean
+  specifications: CFSpecification[]
+}
+
+// TRaSH GitHub raw URL for Custom Formats
+const TRASH_CF_BASE_URL = "https://raw.githubusercontent.com/TRaSH-Guides/Guides/master/docs/json"
+
+export class CustomFormatClient {
+  private baseUrl: string
+  private apiKey: string
+  private apiVersion: string
+
+  constructor(host: string, port: number, apiKey: string, apiVersion = "v3") {
+    this.baseUrl = `http://${host}:${port}/api/${apiVersion}`
+    this.apiKey = apiKey
+    this.apiVersion = apiVersion
+  }
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    const headers: Record<string, string> = {
+      "X-Api-Key": this.apiKey,
+      "Content-Type": "application/json",
+      ...((options.headers as Record<string, string>) || {}),
+    }
+
+    const response = await fetch(url, { ...options, headers })
+
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status} ${response.statusText}`)
+    }
+
+    const text = await response.text()
+    if (!text) return {} as T
+    return JSON.parse(text) as T
+  }
+
+  // Custom Format CRUD
+  async getCustomFormats(): Promise<CustomFormat[]> {
+    return this.request<CustomFormat[]>("/customformat")
+  }
+
+  async getCustomFormat(id: number): Promise<CustomFormat> {
+    return this.request<CustomFormat>(`/customformat/${id}`)
+  }
+
+  async createCustomFormat(cf: Omit<CustomFormat, "id">): Promise<CustomFormat> {
+    return this.request<CustomFormat>("/customformat", {
+      method: "POST",
+      body: JSON.stringify(cf),
+    })
+  }
+
+  async updateCustomFormat(id: number, cf: CustomFormat): Promise<CustomFormat> {
+    return this.request<CustomFormat>(`/customformat/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ ...cf, id }),
+    })
+  }
+
+  async deleteCustomFormat(id: number): Promise<void> {
+    await this.request(`/customformat/${id}`, { method: "DELETE" })
+  }
+
+  // Import from JSON (TRaSH format)
+  async importCustomFormat(cfJson: Omit<CustomFormat, "id">): Promise<CustomFormat> {
+    // Check if CF already exists by name
+    const existing = await this.getCustomFormats()
+    const duplicate = existing.find((cf) => cf.name === cfJson.name)
+
+    if (duplicate) {
+      // Update existing CF
+      return this.updateCustomFormat(duplicate.id!, { ...cfJson, id: duplicate.id })
+    }
+
+    return this.createCustomFormat(cfJson)
+  }
+
+  // Import multiple CFs
+  async importCustomFormats(cfs: Omit<CustomFormat, "id">[]): Promise<{ success: number; failed: number }> {
+    let success = 0
+    let failed = 0
+
+    for (const cf of cfs) {
+      try {
+        await this.importCustomFormat(cf)
+        success++
+      } catch {
+        failed++
+      }
+    }
+
+    return { success, failed }
+  }
+
+  // Fetch CF from TRaSH GitHub
+  static async fetchTRaSHCustomFormat(app: "radarr" | "sonarr", cfName: string): Promise<CustomFormat | null> {
+    try {
+      const url = `${TRASH_CF_BASE_URL}/${app}/cf/${cfName}.json`
+      const response = await fetch(url)
+      if (!response.ok) return null
+      return (await response.json()) as CustomFormat
+    } catch {
+      return null
+    }
+  }
+
+  // Fetch multiple CFs from TRaSH
+  static async fetchTRaSHCustomFormats(
+    app: "radarr" | "sonarr",
+    cfNames: string[]
+  ): Promise<{ cfs: CustomFormat[]; failed: string[] }> {
+    const cfs: CustomFormat[] = []
+    const failed: string[] = []
+
+    for (const name of cfNames) {
+      const cf = await this.fetchTRaSHCustomFormat(app, name)
+      if (cf) {
+        cfs.push(cf)
+      } else {
+        failed.push(name)
+      }
+    }
+
+    return { cfs, failed }
+  }
+}
+
+// Common TRaSH Custom Format names
+export const TRASH_CF_NAMES = {
+  radarr: {
+    unwanted: ["br-disk", "lq", "lq-release-title", "3d", "x265-hd", "extras"],
+    hdr: [
+      "dv-hdr10plus",
+      "dv-hdr10",
+      "dv",
+      "dv-hlg",
+      "dv-sdr",
+      "hdr10plus",
+      "hdr10",
+      "hdr",
+      "hdr-undefined",
+      "pq",
+      "hlg",
+    ],
+    audio: [
+      "truehd-atmos",
+      "dts-x",
+      "truehd",
+      "dts-hd-ma",
+      "flac",
+      "pcm",
+      "dts-hd-hra",
+      "ddplus-atmos",
+      "ddplus",
+      "dts-es",
+      "dts",
+      "aac",
+      "dd",
+    ],
+    streaming: ["amzn", "atvp", "dsnp", "hbo", "hmax", "hulu", "ma", "nf", "pcok", "pmtp"],
+    movieVersions: ["imax-enhanced", "imax", "hybrid", "criterion-collection", "special-edition", "theatrical-cut"],
+    misc: ["repack-proper", "repack2", "multi", "hq-remux", "hq-webdl", "hq"],
+  },
+  sonarr: {
+    unwanted: ["br-disk", "lq", "lq-release-title", "x265-hd", "extras"],
+    hdr: [
+      "dv-hdr10plus",
+      "dv-hdr10",
+      "dv",
+      "dv-hlg",
+      "dv-sdr",
+      "hdr10plus",
+      "hdr10",
+      "hdr",
+      "hdr-undefined",
+      "pq",
+      "hlg",
+    ],
+    streaming: ["amzn", "atvp", "dsnp", "hbo", "hmax", "hulu", "nf", "pcok", "pmtp"],
+    hqGroups: ["web-tier-01", "web-tier-02", "web-tier-03"],
+    misc: ["repack-proper", "repack2", "multi"],
+  },
+}
+
+// Get all CF names for a category
+export function getAllCFNames(app: "radarr" | "sonarr"): string[] {
+  const cfNames = TRASH_CF_NAMES[app]
+  return Object.values(cfNames).flat()
+}
+
+// Get CF names for specific categories
+export function getCFNamesForCategories(app: "radarr" | "sonarr", categories: string[]): string[] {
+  const cfNames = TRASH_CF_NAMES[app] as Record<string, string[]>
+  return categories.flatMap((cat) => cfNames[cat] || [])
+}

package/src/api/prowlarr-api.ts

@@ -0,0 +1,301 @@
+/**
+ * Prowlarr API Client
+ * Manages Indexer Proxies, Sync Profiles, and FlareSolverr integration
+ */
+
+export interface IndexerProxy {
+  id?: number
+  name: string
+  tags: number[]
+  implementation: string
+  configContract: string
+  fields: { name: string; value: unknown }[]
+}
+
+export interface SyncProfile {
+  id?: number
+  name: string
+  enableRss: boolean
+  enableInteractiveSearch: boolean
+  enableAutomaticSearch: boolean
+  minimumSeeders: number
+}
+
+export interface Tag {
+  id: number
+  label: string
+}
+
+export interface Application {
+  id?: number
+  name: string
+  syncLevel: "disabled" | "addOnly" | "fullSync"
+  implementation: string
+  configContract: string
+  fields: { name: string; value: unknown }[]
+  tags: number[]
+}
+
+export type ArrAppType = "Radarr" | "Sonarr" | "Lidarr" | "Readarr"
+
+export class ProwlarrClient {
+  private baseUrl: string
+  private apiKey: string
+
+  constructor(host: string, port: number, apiKey: string) {
+    this.baseUrl = `http://${host}:${port}/api/v1`
+    this.apiKey = apiKey
+  }
+
+  private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    const headers: Record<string, string> = {
+      "X-Api-Key": this.apiKey,
+      "Content-Type": "application/json",
+      ...((options.headers as Record<string, string>) || {}),
+    }
+
+    const response = await fetch(url, { ...options, headers })
+
+    if (!response.ok) {
+      throw new Error(`Prowlarr API request failed: ${response.status} ${response.statusText}`)
+    }
+
+    const text = await response.text()
+    if (!text) return {} as T
+    return JSON.parse(text) as T
+  }
+
+  // Health check
+  async isHealthy(): Promise<boolean> {
+    try {
+      await this.request("/health")
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  // Tag management
+  async getTags(): Promise<Tag[]> {
+    return this.request<Tag[]>("/tag")
+  }
+
+  async createTag(label: string): Promise<Tag> {
+    return this.request<Tag>("/tag", {
+      method: "POST",
+      body: JSON.stringify({ label }),
+    })
+  }
+
+  async getOrCreateTag(label: string): Promise<Tag> {
+    const tags = await this.getTags()
+    const existing = tags.find((t) => t.label.toLowerCase() === label.toLowerCase())
+    if (existing) return existing
+    return this.createTag(label)
+  }
+
+  // Indexer Proxy management
+  async getIndexerProxies(): Promise<IndexerProxy[]> {
+    return this.request<IndexerProxy[]>("/indexerproxy")
+  }
+
+  async addHttpProxy(
+    name: string,
+    host: string,
+    port: number,
+    tags: number[] = [],
+    username?: string,
+    password?: string
+  ): Promise<IndexerProxy> {
+    const fields: { name: string; value: unknown }[] = [
+      { name: "host", value: host },
+      { name: "port", value: port },
+      { name: "username", value: username || "" },
+      { name: "password", value: password || "" },
+    ]
+
+    return this.request<IndexerProxy>("/indexerproxy", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        tags,
+        implementation: "Http",
+        configContract: "HttpSettings",
+        fields,
+      }),
+    })
+  }
+
+  async addSocks5Proxy(
+    name: string,
+    host: string,
+    port: number,
+    tags: number[] = [],
+    username?: string,
+    password?: string
+  ): Promise<IndexerProxy> {
+    const fields: { name: string; value: unknown }[] = [
+      { name: "host", value: host },
+      { name: "port", value: port },
+      { name: "username", value: username || "" },
+      { name: "password", value: password || "" },
+    ]
+
+    return this.request<IndexerProxy>("/indexerproxy", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        tags,
+        implementation: "Socks5",
+        configContract: "Socks5Settings",
+        fields,
+      }),
+    })
+  }
+
+  async addFlareSolverr(name: string, host: string, tags: number[] = [], requestTimeout = 60): Promise<IndexerProxy> {
+    const fields: { name: string; value: unknown }[] = [
+      { name: "host", value: host },
+      { name: "requestTimeout", value: requestTimeout },
+    ]
+
+    return this.request<IndexerProxy>("/indexerproxy", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        tags,
+        implementation: "FlareSolverr",
+        configContract: "FlareSolverrSettings",
+        fields,
+      }),
+    })
+  }
+
+  async deleteIndexerProxy(id: number): Promise<void> {
+    await this.request(`/indexerproxy/${id}`, { method: "DELETE" })
+  }
+
+  // Sync Profile management
+  async getSyncProfiles(): Promise<SyncProfile[]> {
+    return this.request<SyncProfile[]>("/syncprofile")
+  }
+
+  async createSyncProfile(profile: Omit<SyncProfile, "id">): Promise<SyncProfile> {
+    return this.request<SyncProfile>("/syncprofile", {
+      method: "POST",
+      body: JSON.stringify(profile),
+    })
+  }
+
+  // Create TRaSH-recommended sync profiles for limited API indexers
+  async createLimitedAPISyncProfiles(): Promise<{ automatic: SyncProfile; interactive: SyncProfile }> {
+    const existingProfiles = await this.getSyncProfiles()
+
+    const findByName = (name: string) => existingProfiles.find((p) => p.name === name)
+
+    // Automatic Search profile (disable RSS)
+    let automatic = findByName("Automatic Search")
+    if (!automatic) {
+      automatic = await this.createSyncProfile({
+        name: "Automatic Search",
+        enableRss: false,
+        enableInteractiveSearch: true,
+        enableAutomaticSearch: true,
+        minimumSeeders: 1,
+      })
+    }
+
+    // Interactive Search profile (disable RSS and Automatic)
+    let interactive = findByName("Interactive Search")
+    if (!interactive) {
+      interactive = await this.createSyncProfile({
+        name: "Interactive Search",
+        enableRss: false,
+        enableInteractiveSearch: true,
+        enableAutomaticSearch: false,
+        minimumSeeders: 1,
+      })
+    }
+
+    return { automatic, interactive }
+  }
+
+  // Configure FlareSolverr for Cloudflare-protected indexers
+  async configureFlareSolverr(flareSolverrHost: string): Promise<void> {
+    // Create flaresolverr tag
+    const tag = await this.getOrCreateTag("flaresolverr")
+
+    // Check if FlareSolverr proxy already exists
+    const proxies = await this.getIndexerProxies()
+    const existingFS = proxies.find((p) => p.implementation === "FlareSolverr")
+
+    if (!existingFS) {
+      await this.addFlareSolverr("FlareSolverr", flareSolverrHost, [tag.id])
+    }
+  }
+
+  // Application management (sync *arr apps)
+  async getApplications(): Promise<Application[]> {
+    return this.request<Application[]>("/applications")
+  }
+
+  async addApplication(
+    appType: ArrAppType,
+    name: string,
+    prowlarrUrl: string,
+    appUrl: string,
+    appApiKey: string,
+    syncLevel: "disabled" | "addOnly" | "fullSync" = "fullSync"
+  ): Promise<Application> {
+    const fields: { name: string; value: unknown }[] = [
+      { name: "prowlarrUrl", value: prowlarrUrl },
+      { name: "baseUrl", value: appUrl },
+      { name: "apiKey", value: appApiKey },
+      { name: "syncCategories", value: [] },
+    ]
+
+    return this.request<Application>("/applications", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        syncLevel,
+        implementation: appType,
+        configContract: `${appType}Settings`,
+        fields,
+        tags: [],
+      }),
+    })
+  }
+
+  async deleteApplication(id: number): Promise<void> {
+    await this.request(`/applications/${id}`, { method: "DELETE" })
+  }
+
+  // Sync all apps - triggers Prowlarr to push indexers to connected apps
+  async syncApplications(): Promise<void> {
+    await this.request("/applications/action/sync", { method: "POST" })
+  }
+
+  // Add *arr app with auto-detection
+  async addArrApp(
+    appType: ArrAppType,
+    host: string,
+    port: number,
+    apiKey: string,
+    prowlarrHost: string,
+    prowlarrPort: number
+  ): Promise<Application> {
+    const prowlarrUrl = `http://${prowlarrHost}:${prowlarrPort}`
+    const appUrl = `http://${host}:${port}`
+
+    // Check if app already exists
+    const apps = await this.getApplications()
+    const existing = apps.find((a) => a.implementation === appType)
+    if (existing) {
+      return existing
+    }
+
+    return this.addApplication(appType, appType, prowlarrUrl, appUrl, apiKey)
+  }
+}