@muhammedaksam/easiarr 0.1.10 → 0.3.0

package/src/api/qbittorrent-api.ts

@@ -0,0 +1,198 @@
+/**
+ * qBittorrent WebAPI Client
+ * Configures qBittorrent settings via API
+ * API docs: https://github.com/qbittorrent/qBittorrent/wiki/WebUI-API-(qBittorrent-4.1)
+ */
+
+export interface QBittorrentPreferences {
+  save_path?: string
+  temp_path_enabled?: boolean
+  temp_path?: string
+  auto_tmm_enabled?: boolean
+  category_changed_tmm_enabled?: boolean
+  save_path_changed_tmm_enabled?: boolean
+}
+
+export interface QBittorrentCategory {
+  name: string
+  savePath: string
+}
+
+export class QBittorrentClient {
+  private baseUrl: string
+  private username: string
+  private password: string
+  private cookie: string | null = null
+
+  constructor(host: string, port: number, username: string, password: string) {
+    this.baseUrl = `http://${host}:${port}`
+    this.username = username
+    this.password = password
+  }
+
+  /**
+   * Authenticate with qBittorrent WebUI
+   * POST /api/v2/auth/login
+   */
+  async login(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v2/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: `username=${encodeURIComponent(this.username)}&password=${encodeURIComponent(this.password)}`,
+      })
+
+      if (!response.ok) return false
+
+      // Extract SID cookie from response
+      const setCookie = response.headers.get("set-cookie")
+      if (setCookie) {
+        const match = setCookie.match(/SID=([^;]+)/)
+        if (match) {
+          this.cookie = `SID=${match[1]}`
+          return true
+        }
+      }
+
+      // Check response text for "Ok."
+      const text = await response.text()
+      return text === "Ok."
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if connected to qBittorrent
+   */
+  async isConnected(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v2/app/version`, {
+        headers: this.cookie ? { Cookie: this.cookie } : {},
+      })
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get current preferences
+   * GET /api/v2/app/preferences
+   */
+  async getPreferences(): Promise<QBittorrentPreferences> {
+    const response = await fetch(`${this.baseUrl}/api/v2/app/preferences`, {
+      headers: this.cookie ? { Cookie: this.cookie } : {},
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to get preferences: ${response.status}`)
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Set preferences
+   * POST /api/v2/app/setPreferences
+   */
+  async setPreferences(prefs: QBittorrentPreferences): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/app/setPreferences`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `json=${encodeURIComponent(JSON.stringify(prefs))}`,
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to set preferences: ${response.status}`)
+    }
+  }
+
+  /**
+   * Get all categories
+   * GET /api/v2/torrents/categories
+   */
+  async getCategories(): Promise<Record<string, { name: string; savePath: string }>> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/categories`, {
+      headers: this.cookie ? { Cookie: this.cookie } : {},
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to get categories: ${response.status}`)
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Create a category
+   * POST /api/v2/torrents/createCategory
+   */
+  async createCategory(name: string, savePath: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/createCategory`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `category=${encodeURIComponent(name)}&savePath=${encodeURIComponent(savePath)}`,
+    })
+
+    // 409 means category already exists - that's OK
+    if (!response.ok && response.status !== 409) {
+      throw new Error(`Failed to create category: ${response.status}`)
+    }
+  }
+
+  /**
+   * Edit a category's save path
+   * POST /api/v2/torrents/editCategory
+   */
+  async editCategory(name: string, savePath: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/v2/torrents/editCategory`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...(this.cookie ? { Cookie: this.cookie } : {}),
+      },
+      body: `category=${encodeURIComponent(name)}&savePath=${encodeURIComponent(savePath)}`,
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to edit category: ${response.status}`)
+    }
+  }
+
+  /**
+   * Configure qBittorrent for TRaSH Guide compliance
+   * Sets proper save paths and creates categories based on enabled apps
+   * @param categories - Array of {name, savePath} for each enabled *arr app
+   */
+  async configureTRaSHCompliant(categories: QBittorrentCategory[] = []): Promise<void> {
+    // 1. Set global preferences
+    await this.setPreferences({
+      save_path: "/data/torrents",
+      temp_path_enabled: false,
+      auto_tmm_enabled: true,
+      category_changed_tmm_enabled: true,
+      save_path_changed_tmm_enabled: true,
+    })
+
+    // 2. Create categories for each enabled media type
+    for (const cat of categories) {
+      try {
+        await this.createCategory(cat.name, cat.savePath)
+      } catch {
+        // Try to update existing category
+        try {
+          await this.editCategory(cat.name, cat.savePath)
+        } catch {
+          // Ignore - category might not exist or be locked
+        }
+      }
+    }
+  }
+}

package/src/api/quality-profile-api.ts

@@ -0,0 +1,205 @@
+/**
+ * Quality Profile API Client
+ * Manages Quality Profiles and Custom Format scoring for Radarr/Sonarr
+ */
+
+export interface QualityItem {
+  id?: number
+  name?: string
+  quality?: {
+    id: number
+    name: string
+    source: string
+    resolution: number
+  }
+  items?: QualityItem[]
+  allowed: boolean
+}
+
+export interface FormatItem {
+  format: number
+  name?: string
+  score: number
+}
+
+export interface QualityProfile {
+  id?: number
+  name: string
+  upgradeAllowed: boolean
+  cutoff: number
+  minFormatScore: number
+  cutoffFormatScore: number
+  formatItems: FormatItem[]
+  language?: { id: number; name: string }
+  items: QualityItem[]
+}
+
+export interface QualityDefinition {
+  id: number
+  quality: {
+    id: number
+    name: string
+    source: string
+    resolution: number
+  }
+  title: string
+  weight: number
+  minSize: number
+  maxSize: number
+  preferredSize: number
+}
+
+export class QualityProfileClient {
+  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
+  }
+
+  // Quality Profile methods
+  async getQualityProfiles(): Promise<QualityProfile[]> {
+    return this.request<QualityProfile[]>("/qualityprofile")
+  }
+
+  async getQualityProfile(id: number): Promise<QualityProfile> {
+    return this.request<QualityProfile>(`/qualityprofile/${id}`)
+  }
+
+  async createQualityProfile(profile: Omit<QualityProfile, "id">): Promise<QualityProfile> {
+    return this.request<QualityProfile>("/qualityprofile", {
+      method: "POST",
+      body: JSON.stringify(profile),
+    })
+  }
+
+  async updateQualityProfile(id: number, profile: QualityProfile): Promise<QualityProfile> {
+    return this.request<QualityProfile>(`/qualityprofile/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ ...profile, id }),
+    })
+  }
+
+  async deleteQualityProfile(id: number): Promise<void> {
+    await this.request(`/qualityprofile/${id}`, { method: "DELETE" })
+  }
+
+  // Quality Definition methods (for size limits)
+  async getQualityDefinitions(): Promise<QualityDefinition[]> {
+    return this.request<QualityDefinition[]>("/qualitydefinition")
+  }
+
+  async updateQualityDefinitions(definitions: QualityDefinition[]): Promise<QualityDefinition[]> {
+    return this.request<QualityDefinition[]>("/qualitydefinition/update", {
+      method: "PUT",
+      body: JSON.stringify(definitions),
+    })
+  }
+
+  // Helper: Get quality by name from existing profiles
+  async getQualityIdByName(name: string): Promise<number | null> {
+    const profiles = await this.getQualityProfiles()
+    if (profiles.length === 0) return null
+
+    const findQuality = (items: QualityItem[]): number | null => {
+      for (const item of items) {
+        if (item.quality?.name === name) return item.quality.id
+        if (item.items) {
+          const found = findQuality(item.items)
+          if (found !== null) return found
+        }
+      }
+      return null
+    }
+
+    return findQuality(profiles[0].items)
+  }
+
+  // Create TRaSH-recommended profile
+  async createTRaSHProfile(
+    name: string,
+    cutoffQualityName: string,
+    allowedQualities: string[],
+    cfScores: Record<string, number> = {}
+  ): Promise<QualityProfile> {
+    // Get existing profile to clone quality structure
+    const existingProfiles = await this.getQualityProfiles()
+    if (existingProfiles.length === 0) {
+      throw new Error("No existing profiles to clone quality structure from")
+    }
+
+    const baseProfile = existingProfiles[0]
+    const cutoffId = await this.getQualityIdByName(cutoffQualityName)
+
+    if (cutoffId === null) {
+      throw new Error(`Quality "${cutoffQualityName}" not found`)
+    }
+
+    // Build quality items with allowed flags
+    const setAllowed = (items: QualityItem[]): QualityItem[] => {
+      return items.map((item) => {
+        if (item.items) {
+          return { ...item, items: setAllowed(item.items) }
+        }
+        return {
+          ...item,
+          allowed: item.quality ? allowedQualities.includes(item.quality.name) : false,
+        }
+      })
+    }
+
+    // Get custom formats and map scores
+    const formatItems: FormatItem[] = baseProfile.formatItems.map((fi) => ({
+      format: fi.format,
+      name: fi.name,
+      score: cfScores[fi.name || ""] ?? 0,
+    }))
+
+    const newProfile: Omit<QualityProfile, "id"> = {
+      name,
+      upgradeAllowed: true,
+      cutoff: cutoffId,
+      minFormatScore: 0,
+      cutoffFormatScore: 10000,
+      formatItems,
+      language: baseProfile.language,
+      items: setAllowed(baseProfile.items),
+    }
+
+    return this.createQualityProfile(newProfile)
+  }
+
+  // Update CF scores on existing profile
+  async updateProfileCFScores(profileId: number, cfScores: Record<string, number>): Promise<QualityProfile> {
+    const profile = await this.getQualityProfile(profileId)
+
+    profile.formatItems = profile.formatItems.map((fi) => ({
+      ...fi,
+      score: cfScores[fi.name || ""] ?? fi.score,
+    }))
+
+    return this.updateQualityProfile(profileId, profile)
+  }
+}

package/src/apps/registry.ts

@@ -138,10 +138,8 @@ export const APPS: Record<AppId, AppDefinition> = {
       enabledKey: "api_enabled",
       generateIfMissing: true,
     },
-    rootFolder: {
-      path: "/data/media/comics",
-      apiVersion: "v1",
-    },
+    // Note: Mylar3 is NOT an *arr app - has different API format (?cmd=<endpoint>)
+    // Root folder is configured via Web UI settings, not API
   },
 
   whisparr: {
@@ -246,7 +244,8 @@ export const APPS: Record<AppId, AppDefinition> = {
     image: "lscr.io/linuxserver/qbittorrent:latest",
     puid: 13007,
     pgid: 13000,
-    volumes: (root) => [`${root}/config/qbittorrent:/config`, `${root}/data/torrents:/data/torrents`],
+    // TRaSH: Mount full /data for consistent paths with *arr apps (enables hardlinks)
+    volumes: (root) => [`${root}/config/qbittorrent:/config`, `${root}/data:/data`],
     environment: { WEBUI_PORT: "8080" },
     trashGuide: "docs/Downloaders/qBittorrent/",
   },
@@ -260,7 +259,8 @@ export const APPS: Record<AppId, AppDefinition> = {
     image: "lscr.io/linuxserver/sabnzbd:latest",
     puid: 13011,
     pgid: 13000,
-    volumes: (root) => [`${root}/config/sabnzbd:/config`, `${root}/data/usenet:/data/usenet`],
+    // TRaSH: Mount full /data for consistent paths with *arr apps (enables hardlinks)
+    volumes: (root) => [`${root}/config/sabnzbd:/config`, `${root}/data:/data`],
 
     trashGuide: "docs/Downloaders/SABnzbd/",
     apiKeyMeta: {

package/src/compose/generator.ts

@@ -3,12 +3,12 @@
  * Generates docker-compose.yml from Easiarr configuration
  */
 
-import { writeFile, readFile } from "node:fs/promises"
-import { existsSync } from "node:fs"
+import { writeFile } from "node:fs/promises"
 import type { EasiarrConfig, AppConfig, TraefikConfig, AppId } from "../config/schema"
 import { getComposePath } from "../config/manager"
 import { getApp } from "../apps/registry"
 import { generateServiceYaml } from "./templates"
+import { updateEnv } from "../utils/env"
 
 export interface ComposeService {
   image: string
@@ -205,30 +205,12 @@ export async function saveCompose(config: EasiarrConfig): Promise<string> {
 }
 
 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")
+  // Update .env with global configuration values
+  await updateEnv({
+    ROOT_DIR: config.rootDir,
+    TIMEZONE: config.timezone,
+    PUID: config.uid.toString(),
+    PGID: config.gid.toString(),
+    UMASK: config.umask,
+  })
 }