@muhammedaksam/easiarr 1.4.0 → 1.6.0

package/src/api/qbittorrent-api.ts

@@ -1,300 +0,0 @@
-/**
- * qBittorrent WebAPI Client
- * Configures qBittorrent settings via API
- * API docs: https://github.com/qbittorrent/qBittorrent/wiki/WebUI-API-(qBittorrent-4.1)
- */
-
-import type { AutoSetupOptions, AutoSetupResult, IAutoSetupClient } from "./auto-setup-types"
-import { debugLog } from "~/utils/debug"
-import { BaseApiClient } from "./base-api"
-
-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
-  max_ratio?: number
-  max_ratio_enabled?: boolean
-  max_ratio_act?: number
-  max_seeding_time?: number
-  max_seeding_time_enabled?: boolean
-  queueing_enabled?: boolean
-  web_ui_username?: string
-  web_ui_password?: string
-  listen_port?: number
-  upnp?: boolean
-  natpmp?: boolean
-  dl_limit?: number
-  up_limit?: number
-  limit_utp_rate?: boolean
-  limit_tcp_overhead?: boolean
-  limit_lan_peers?: boolean
-  enable_dht?: boolean
-  enable_pex?: boolean
-  enable_lsd?: boolean
-  encryption_mode?: number
-  anonymous_mode?: boolean
-  add_trackers_enabled?: boolean
-  pre_allocate_all?: boolean
-  incomplete_files_ext?: boolean
-  create_subfolder_enabled?: boolean
-}
-
-export interface QBittorrentCategory {
-  name: string
-  savePath: string
-}
-
-export class QBittorrentClient extends BaseApiClient implements IAutoSetupClient {
-  protected readonly logPrefix = "qBittorrent"
-  private username: string
-  private password: string
-  private cookie: string | null = null
-
-  constructor(host: string, port: number, username: string, password: string) {
-    super(host, port)
-    this.username = username
-    this.password = password
-  }
-
-  /**
-   * Authenticate with qBittorrent WebUI
-   */
-  async login(): Promise<boolean> {
-    try {
-      debugLog("qBittorrent", `Logging in to ${this.baseUrl} as ${this.username}`)
-      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
-      }
-
-      const setCookie = response.headers.get("set-cookie")
-      if (setCookie) {
-        const match = setCookie.match(/SID=([^;]+)/)
-        if (match) {
-          this.cookie = `SID=${match[1]}`
-          return true
-        }
-      }
-
-      const text = await response.text()
-      return text === "Ok."
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Check if connected
-   */
-  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
-   */
-  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
-   */
-  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
-   */
-  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
-   */
-  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)}`,
-    })
-
-    if (!response.ok && response.status !== 409) {
-      throw new Error(`Failed to create category: ${response.status}`)
-    }
-  }
-
-  /**
-   * Edit a category's save path
-   */
-  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
-   */
-  async configureTRaSHCompliant(
-    categories: QBittorrentCategory[] = [],
-    auth?: { user: string; pass: string }
-  ): Promise<void> {
-    debugLog("qBittorrent", "Configuring TRaSH-compliant settings")
-
-    const prefs: Record<string, unknown> = {
-      save_path: "/data/torrents",
-      temp_path_enabled: false,
-      auto_tmm_enabled: true,
-      category_changed_tmm_enabled: true,
-      save_path_changed_tmm_enabled: true,
-      pre_allocate_all: false,
-      incomplete_files_ext: true,
-      create_subfolder_enabled: true,
-      upnp: false,
-      natpmp: false,
-      dl_limit: -1,
-      up_limit: -1,
-      limit_utp_rate: true,
-      limit_tcp_overhead: false,
-      limit_lan_peers: true,
-      enable_dht: true,
-      enable_pex: true,
-      enable_lsd: true,
-      encryption_mode: 0,
-      anonymous_mode: false,
-      add_trackers_enabled: false,
-      queueing_enabled: true,
-      max_ratio: -1,
-      max_ratio_enabled: false,
-      max_seeding_time_enabled: false,
-      max_ratio_act: 0,
-    }
-
-    if (auth) {
-      prefs.web_ui_username = auth.user
-      prefs.web_ui_password = auth.pass
-    }
-
-    await this.setPreferences(prefs)
-
-    for (const cat of categories) {
-      try {
-        await this.createCategory(cat.name, cat.savePath)
-      } catch {
-        try {
-          await this.editCategory(cat.name, cat.savePath)
-        } catch {
-          // Ignore
-        }
-      }
-    }
-  }
-
-  /**
-   * Check if qBittorrent is reachable
-   */
-  async isHealthy(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v2/app/version`)
-      return response.ok || response.status === 403
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Check if already configured
-   */
-  async isInitialized(): Promise<boolean> {
-    return this.isConnected()
-  }
-
-  /**
-   * Run the auto-setup process
-   */
-  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
-    const { username, password } = options
-
-    try {
-      const healthy = await this.isHealthy()
-      if (!healthy) {
-        return { success: false, message: "qBittorrent not reachable" }
-      }
-
-      this.username = username
-      this.password = password
-
-      const loggedIn = await this.login()
-      if (!loggedIn) {
-        return { success: false, message: "Login failed - check credentials" }
-      }
-
-      await this.configureTRaSHCompliant([], { user: username, pass: password })
-
-      return {
-        success: true,
-        message: "Configured with TRaSH-compliant settings",
-        data: { trashCompliant: true },
-      }
-    } catch (error) {
-      return { success: false, message: `${error}` }
-    }
-  }
-}

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

@@ -1,272 +0,0 @@
-/**
- * Quality Profile API Client
- * Manages Quality Profiles and Custom Format scoring for Radarr/Sonarr/Lidarr
- */
-
-import {
-  TRASH_LIDARR_QUALITY_DEFINITIONS,
-  TRASH_RADARR_QUALITY_DEFINITIONS,
-  TRASH_SONARR_QUALITY_DEFINITIONS,
-} from "~/config/trash-quality-definitions"
-import { debugLog } from "~/utils/debug"
-
-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[]> {
-    const updated: QualityDefinition[] = []
-
-    // Update each definition individually as bulk update is not reliably supported across all versions
-    for (const def of definitions) {
-      if (!def.id) continue
-
-      try {
-        const result = await this.request<QualityDefinition>(`/qualitydefinition/${def.id}`, {
-          method: "PUT",
-          body: JSON.stringify(def),
-        })
-        updated.push(result)
-      } catch (e) {
-        debugLog("QualityProfile", `Failed to update definition ${def.id}: ${e}`)
-      }
-    }
-    return updated
-  }
-
-  // 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)
-  }
-
-  // Apply TRaSH/Davo Quality Definitions (File Size Limits)
-  async updateTrashQualityDefinitions(appType: "radarr" | "sonarr" | "lidarr"): Promise<void> {
-    try {
-      debugLog("QualityProfile", `Updating Quality Definitions for ${appType}`)
-      const definitions = await this.getQualityDefinitions()
-
-      // Get appropriate definitions based on app type
-      let trashDefs
-      if (appType === "radarr") {
-        trashDefs = TRASH_RADARR_QUALITY_DEFINITIONS
-      } else if (appType === "sonarr") {
-        trashDefs = TRASH_SONARR_QUALITY_DEFINITIONS
-      } else {
-        trashDefs = TRASH_LIDARR_QUALITY_DEFINITIONS
-      }
-
-      let updatedCount = 0
-
-      const newDefinitions = definitions.map((def) => {
-        const trashDef = trashDefs.find((t) => t.quality === def.quality.name)
-        if (trashDef) {
-          updatedCount++
-          return {
-            ...def,
-            minSize: trashDef.min,
-            maxSize: trashDef.max,
-            preferredSize: trashDef.preferred,
-          }
-        }
-        return def
-      })
-
-      if (updatedCount > 0) {
-        await this.updateQualityDefinitions(newDefinitions)
-        debugLog("QualityProfile", `Successfully updated ${updatedCount} quality definitions`)
-      } else {
-        debugLog("QualityProfile", "No matching quality definitions found to update")
-      }
-    } catch (e) {
-      debugLog("QualityProfile", `Failed to update quality definitions: ${e}`)
-      throw e
-    }
-  }
-}