@muhammedaksam/easiarr 1.4.0 → 1.4.1

package/src/api/overseerr-api.ts

@@ -1,392 +0,0 @@
-/**
- * Overseerr API Client
- * Handles Overseerr auto-setup for Plex media requests
- * Fully automated using Plex token authentication
- */
-
-import type { AutoSetupOptions, AutoSetupResult, IAutoSetupClient } from "./auto-setup-types"
-import { debugLog } from "~/utils/debug"
-import { BaseApiClient } from "./base-api"
-
-interface OverseerrStatus {
-  version: string
-  status: number
-}
-
-interface OverseerrUser {
-  id: number
-  email: string
-  username?: string
-  plexToken?: string
-  plexUsername?: string
-  userType: number
-  permissions: number
-  avatar?: string
-}
-
-interface PlexSettings {
-  name: string
-  machineId: string
-  ip: string
-  port: number
-  useSsl?: boolean
-  libraries: { id: string; name: string; enabled: boolean }[]
-}
-
-interface PlexDevice {
-  name: string
-  clientIdentifier: string
-  connection: { uri: string; local: boolean }[]
-}
-
-interface RadarrSettings {
-  name: string
-  hostname: string
-  port: number
-  apiKey: string
-  useSsl?: boolean
-  baseUrl?: string
-  activeProfileId: number
-  activeDirectory: string
-  is4k: boolean
-  isDefault: boolean
-  minimumAvailability?: string
-}
-
-interface SonarrSettings {
-  name: string
-  hostname: string
-  port: number
-  apiKey: string
-  useSsl?: boolean
-  baseUrl?: string
-  activeProfileId: number
-  activeDirectory: string
-  activeAnimeProfileId?: number
-  activeAnimeDirectory?: string
-  is4k: boolean
-  isDefault: boolean
-  enableSeasonFolders: boolean
-}
-
-interface MainSettings {
-  apiKey: string
-  applicationTitle?: string
-  applicationUrl?: string
-}
-
-export class OverseerrClient extends BaseApiClient implements IAutoSetupClient {
-  protected readonly logPrefix = "OverseerrApi"
-  private apiKey?: string
-  private sessionCookie?: string
-
-  constructor(host: string, port: number = 5055, apiKey?: string) {
-    super(host, port)
-    this.apiKey = apiKey
-  }
-
-  /**
-   * Common headers for Overseerr API requests
-   */
-  private getHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-    }
-    if (this.apiKey) {
-      headers["X-Api-Key"] = this.apiKey
-    }
-    if (this.sessionCookie) {
-      headers["Cookie"] = this.sessionCookie
-    }
-    return headers
-  }
-
-  /**
-   * Set API key for authenticated requests
-   */
-  setApiKey(apiKey: string): void {
-    this.apiKey = apiKey
-  }
-
-  /**
-   * Check if Overseerr is reachable
-   */
-  async isHealthy(): Promise<boolean> {
-    const response = await this.get<OverseerrStatus>("/api/v1/status")
-    return response.success
-  }
-
-  /**
-   * Check if Overseerr is already configured
-   */
-  async isInitialized(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/public`, {
-        method: "GET",
-      })
-      if (!response.ok) return false
-      const data = await response.json()
-      return data.initialized === true
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Authenticate with Overseerr using a Plex token
-   */
-  async authenticateWithPlex(plexToken: string): Promise<OverseerrUser | null> {
-    debugLog("OverseerrApi", "Authenticating with Plex token...")
-
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/auth/plex`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-        },
-        body: JSON.stringify({ authToken: plexToken }),
-      })
-
-      if (response.ok) {
-        const setCookie = response.headers.get("set-cookie")
-        if (setCookie) {
-          this.sessionCookie = setCookie.split(";")[0]
-        }
-        return await response.json()
-      }
-      return null
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Get available Plex servers
-   */
-  async getPlexServers(): Promise<PlexDevice[]> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/plex/devices/servers`, {
-        method: "GET",
-        headers: this.getHeaders(),
-      })
-      if (response.ok) {
-        return response.json()
-      }
-    } catch {
-      // Ignore
-    }
-    return []
-  }
-
-  /**
-   * Initialize Overseerr
-   */
-  async initialize(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/initialize`, {
-        method: "POST",
-        headers: this.getHeaders(),
-      })
-      return response.ok
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Get main settings (includes API key)
-   */
-  async getMainSettings(): Promise<MainSettings | null> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/main`, {
-        method: "GET",
-        headers: this.getHeaders(),
-      })
-      if (response.ok) {
-        return response.json()
-      }
-    } catch {
-      // Ignore
-    }
-    return null
-  }
-
-  /**
-   * Set application URL
-   */
-  async setApplicationUrl(applicationUrl: string): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/main`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify({ applicationUrl }),
-      })
-      return response.ok
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Sync Plex libraries
-   */
-  async syncPlexLibraries(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/plex/library?sync=true`, {
-        method: "GET",
-        headers: this.getHeaders(),
-      })
-      return response.ok
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Start a full Plex library scan
-   */
-  async startPlexScan(): Promise<boolean> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/v1/settings/plex/sync`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify({ start: true }),
-      })
-      return response.ok
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Get Overseerr status
-   */
-  async getStatus(): Promise<OverseerrStatus | null> {
-    const response = await this.get<OverseerrStatus>("/api/v1/status")
-    return response.data ?? null
-  }
-
-  /**
-   * Get current Plex settings
-   */
-  async getPlexSettings(): Promise<PlexSettings | null> {
-    const response = await fetch(`${this.baseUrl}/api/v1/settings/plex`, {
-      method: "GET",
-      headers: this.getHeaders(),
-    })
-    if (response.ok) {
-      return response.json()
-    }
-    return null
-  }
-
-  /**
-   * Update Plex settings
-   */
-  async updatePlexSettings(settings: Partial<PlexSettings>): Promise<boolean> {
-    const response = await fetch(`${this.baseUrl}/api/v1/settings/plex`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: JSON.stringify(settings),
-    })
-    return response.ok
-  }
-
-  /**
-   * Add Radarr server
-   */
-  async addRadarrServer(settings: RadarrSettings): Promise<boolean> {
-    const response = await fetch(`${this.baseUrl}/api/v1/settings/radarr`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: JSON.stringify(settings),
-    })
-    return response.ok
-  }
-
-  /**
-   * Add Sonarr server
-   */
-  async addSonarrServer(settings: SonarrSettings): Promise<boolean> {
-    const response = await fetch(`${this.baseUrl}/api/v1/settings/sonarr`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: JSON.stringify(settings),
-    })
-    return response.ok
-  }
-
-  /**
-   * Run the auto-setup process
-   */
-  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
-    try {
-      const healthy = await this.isHealthy()
-      if (!healthy) {
-        return { success: false, message: "Overseerr not reachable" }
-      }
-
-      const initialized = await this.isInitialized()
-      if (initialized) {
-        const settings = await this.getMainSettings()
-        if (settings?.apiKey) {
-          return {
-            success: true,
-            message: "Already configured",
-            data: { apiKey: settings.apiKey },
-          }
-        }
-        return { success: true, message: "Already configured" }
-      }
-
-      const plexToken = options.plexToken || process.env.API_KEY_PLEX
-      if (!plexToken) {
-        return {
-          success: false,
-          message: "Plex token required (set API_KEY_PLEX env var)",
-        }
-      }
-
-      const user = await this.authenticateWithPlex(plexToken)
-      if (!user) {
-        return { success: false, message: "Failed to authenticate with Plex" }
-      }
-
-      const servers = await this.getPlexServers()
-      if (servers.length > 0) {
-        const server = servers[0]
-        const localConn = server.connection.find((c) => c.local) || server.connection[0]
-        if (localConn) {
-          const url = new URL(localConn.uri)
-          await this.updatePlexSettings({
-            name: server.name,
-            ip: url.hostname,
-            port: parseInt(url.port) || 32400,
-          })
-        }
-      }
-
-      await this.syncPlexLibraries()
-
-      const initSuccess = await this.initialize()
-      if (!initSuccess) {
-        return { success: false, message: "Failed to initialize Overseerr" }
-      }
-
-      const settings = await this.getMainSettings()
-      const apiKey = settings?.apiKey
-
-      await this.startPlexScan()
-
-      return {
-        success: true,
-        message: "Overseerr configured successfully",
-        data: apiKey ? { apiKey } : undefined,
-      }
-    } catch (error) {
-      return { success: false, message: `${error}` }
-    }
-  }
-}

package/src/api/plex-api.ts

@@ -1,308 +0,0 @@
-/**
- * Plex API Client
- * Handles Plex Media Server auto-setup including server claiming and library creation
- */
-
-import type { AutoSetupOptions, AutoSetupResult, IAutoSetupClient } from "./auto-setup-types"
-import { debugLog } from "~/utils/debug"
-import { BaseApiClient } from "./base-api"
-
-// Plex client identifier for API requests
-const PLEX_CLIENT_ID = "easiarr"
-const PLEX_PRODUCT = "Easiarr"
-const PLEX_VERSION = "1.0.0"
-const PLEX_DEVICE = "Server"
-
-interface PlexLibrarySection {
-  key: string
-  type: string
-  title: string
-  agent: string
-  scanner: string
-  language: string
-  Location: { id: number; path: string }[]
-}
-
-interface PlexServerInfo {
-  machineIdentifier: string
-  version: string
-  claimed: boolean
-}
-
-export class PlexApiClient extends BaseApiClient implements IAutoSetupClient {
-  protected readonly logPrefix = "PlexApi"
-  private token?: string
-
-  constructor(host: string, port: number = 32400, token?: string) {
-    super(host, port)
-    this.token = token
-  }
-
-  /**
-   * Set the Plex token for authenticated requests
-   */
-  setToken(token: string): void {
-    this.token = token
-  }
-
-  /**
-   * Common headers for Plex API requests
-   */
-  private getHeaders(): Record<string, string> {
-    const headers: Record<string, string> = {
-      Accept: "application/json",
-      "X-Plex-Client-Identifier": PLEX_CLIENT_ID,
-      "X-Plex-Product": PLEX_PRODUCT,
-      "X-Plex-Version": PLEX_VERSION,
-      "X-Plex-Device": PLEX_DEVICE,
-    }
-    if (this.token) {
-      headers["X-Plex-Token"] = this.token
-    }
-    return headers
-  }
-
-  /**
-   * Check if Plex server is reachable
-   */
-  async isHealthy(): Promise<boolean> {
-    const response = await this.get<unknown>("/identity", { headers: this.getHeaders() })
-    return response.success
-  }
-
-  /**
-   * Check if server is already claimed (initialized)
-   */
-  async isInitialized(): Promise<boolean> {
-    try {
-      const info = await this.getServerInfo()
-      return info.claimed
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * Get server information including claim status
-   */
-  async getServerInfo(): Promise<PlexServerInfo> {
-    const response = await fetch(`${this.baseUrl}/`, {
-      method: "GET",
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to get server info: ${response.status}`)
-    }
-
-    const data = await response.json()
-    const container = data.MediaContainer
-
-    return {
-      machineIdentifier: container.machineIdentifier,
-      version: container.version,
-      claimed: container.myPlex === true || !!container.myPlexUsername,
-    }
-  }
-
-  /**
-   * Claim the server using a claim token from plex.tv/claim
-   */
-  async claimServer(claimToken: string): Promise<void> {
-    debugLog("PlexApi", "Claiming server with token...")
-
-    const token = claimToken.startsWith("claim-") ? claimToken : `claim-${claimToken}`
-
-    const response = await this.post<unknown>(`/myplex/claim?token=${token}`, undefined, {
-      headers: this.getHeaders(),
-    })
-
-    if (!response.success) {
-      throw new Error(`Failed to claim server: ${response.status}`)
-    }
-
-    debugLog("PlexApi", "Server claimed successfully")
-  }
-
-  /**
-   * Get list of library sections
-   */
-  async getLibrarySections(): Promise<PlexLibrarySection[]> {
-    const response = await fetch(`${this.baseUrl}/library/sections`, {
-      method: "GET",
-      headers: this.getHeaders(),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Failed to get library sections: ${response.status}`)
-    }
-
-    const data = await response.json()
-    return data.MediaContainer?.Directory || []
-  }
-
-  /**
-   * Create a library section
-   */
-  async createLibrary(
-    name: string,
-    type: "movie" | "show" | "artist",
-    path: string,
-    language: string = "en-US"
-  ): Promise<void> {
-    debugLog("PlexApi", `Creating library: ${name} (${type}) at ${path}`)
-
-    const agents: Record<string, { agent: string; scanner: string }> = {
-      movie: { agent: "tv.plex.agents.movie", scanner: "Plex Movie" },
-      show: { agent: "tv.plex.agents.series", scanner: "Plex TV Series" },
-      artist: { agent: "tv.plex.agents.music", scanner: "Plex Music" },
-    }
-
-    const config = agents[type]
-    if (!config) {
-      throw new Error(`Unknown library type: ${type}`)
-    }
-
-    const params = new URLSearchParams({
-      name,
-      type,
-      agent: config.agent,
-      scanner: config.scanner,
-      language,
-      location: path,
-    })
-
-    const response = await this.post<unknown>(`/library/sections?${params.toString()}`, undefined, {
-      headers: this.getHeaders(),
-    })
-
-    if (!response.success) {
-      throw new Error(`Failed to create library: ${response.status}`)
-    }
-
-    debugLog("PlexApi", `Library "${name}" created successfully`)
-  }
-
-  /**
-   * Check if a library with the given path already exists
-   */
-  async libraryExistsForPath(path: string): Promise<boolean> {
-    const sections = await this.getLibrarySections()
-    return sections.some((section) => section.Location?.some((loc) => loc.path === path))
-  }
-
-  /**
-   * Trigger a library scan for all sections
-   */
-  async scanAllLibraries(): Promise<void> {
-    const sections = await this.getLibrarySections()
-    for (const section of sections) {
-      await fetch(`${this.baseUrl}/library/sections/${section.key}/refresh`, {
-        method: "GET",
-        headers: this.getHeaders(),
-      })
-    }
-    debugLog("PlexApi", "Triggered scan for all libraries")
-  }
-
-  /**
-   * Create libraries based on enabled *arr apps
-   */
-  private async createDefaultLibraries(enabledApps?: string[]): Promise<number> {
-    const libraryMap = [
-      { app: "radarr", name: "Movies", type: "movie" as const, path: "/data/media/movies" },
-      { app: "sonarr", name: "TV Shows", type: "show" as const, path: "/data/media/tv" },
-      { app: "lidarr", name: "Music", type: "artist" as const, path: "/data/media/music" },
-    ]
-
-    const libraries = enabledApps
-      ? libraryMap.filter((lib) => enabledApps.includes(lib.app))
-      : libraryMap
-
-    let librariesCreated = 0
-    for (const lib of libraries) {
-      const exists = await this.libraryExistsForPath(lib.path)
-      if (!exists) {
-        try {
-          await this.createLibrary(lib.name, lib.type, lib.path)
-          librariesCreated++
-        } catch (e) {
-          debugLog("PlexApi", `Could not create library ${lib.name}: ${e}`)
-        }
-      }
-    }
-    return librariesCreated
-  }
-
-  /**
-   * Run the auto-setup process for Plex
-   */
-  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
-    const { env, plexToken, enabledApps } = options
-
-    const healthy = await this.isHealthy()
-    if (!healthy) {
-      return { success: false, message: "Plex server not reachable" }
-    }
-
-    if (plexToken) {
-      this.setToken(plexToken)
-    } else if (env["API_KEY_PLEX"]) {
-      this.setToken(env["API_KEY_PLEX"])
-    }
-
-    try {
-      const serverInfo = await this.getServerInfo()
-      if (serverInfo.claimed) {
-        const librariesCreated = await this.createDefaultLibraries(enabledApps)
-        return {
-          success: true,
-          message:
-            librariesCreated > 0
-              ? `Already claimed, ${librariesCreated} libraries configured`
-              : "Already claimed",
-          data: {
-            machineIdentifier: serverInfo.machineIdentifier,
-            version: serverInfo.version,
-            librariesCreated,
-          },
-        }
-      }
-    } catch (e) {
-      const errMsg = String(e)
-      if (errMsg.includes("401")) {
-        return {
-          success: true,
-          message: "Already claimed - add API_KEY_PLEX to .env to create libraries",
-          data: { requiresWizard: false },
-        }
-      }
-    }
-
-    const claimToken = env["PLEX_CLAIM"]
-    if (!claimToken) {
-      return {
-        success: false,
-        message: "No PLEX_CLAIM token. Get one from https://plex.tv/claim (4-min expiry)",
-      }
-    }
-
-    try {
-      await this.claimServer(claimToken)
-      const serverInfo = await this.getServerInfo()
-      const librariesCreated = await this.createDefaultLibraries(enabledApps)
-
-      return {
-        success: true,
-        message: `Server claimed, ${librariesCreated} libraries configured`,
-        data: {
-          machineIdentifier: serverInfo.machineIdentifier,
-          version: serverInfo.version,
-          librariesCreated,
-        },
-      }
-    } catch (error) {
-      return { success: false, message: `${error}` }
-    }
-  }
-}