@muhammedaksam/easiarr 1.0.0 → 1.1.0

package/src/api/plex-api.ts

@@ -0,0 +1,329 @@
+/**
+ * Plex API Client
+ * Handles Plex Media Server auto-setup including server claiming and library creation
+ */
+
+import { debugLog } from "../utils/debug"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
+
+// 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 implements IAutoSetupClient {
+  private host: string
+  private port: number
+  private token?: string
+
+  constructor(host: string, port: number = 32400, token?: string) {
+    this.host = host
+    this.port = port
+    this.token = token
+  }
+
+  /**
+   * Set the Plex token for authenticated requests
+   */
+  setToken(token: string): void {
+    this.token = token
+  }
+
+  /**
+   * Get base URL for local Plex server
+   */
+  private get baseUrl(): string {
+    return `http://${this.host}:${this.port}`
+  }
+
+  /**
+   * 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> {
+    try {
+      const response = await fetch(`${this.baseUrl}/identity`, {
+        method: "GET",
+        headers: this.getHeaders(),
+      })
+      debugLog("PlexApi", `Health check: ${response.status}`)
+      return response.ok
+    } catch (error) {
+      debugLog("PlexApi", `Health check failed: ${error}`)
+      return false
+    }
+  }
+
+  /**
+   * 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
+   * The claim token has a 4-minute expiry
+   */
+  async claimServer(claimToken: string): Promise<void> {
+    debugLog("PlexApi", "Claiming server with token...")
+
+    // Claim token should start with "claim-"
+    const token = claimToken.startsWith("claim-") ? claimToken : `claim-${claimToken}`
+
+    const response = await fetch(`${this.baseUrl}/myplex/claim?token=${token}`, {
+      method: "POST",
+      headers: this.getHeaders(),
+    })
+
+    if (!response.ok) {
+      const text = await response.text()
+      throw new Error(`Failed to claim server: ${response.status} - ${text}`)
+    }
+
+    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
+   * @param name - Display name for the library
+   * @param type - Library type: movie, show, artist (music)
+   * @param path - Path to media files (inside container)
+   * @param language - Language code (default: en-US)
+   */
+  async createLibrary(
+    name: string,
+    type: "movie" | "show" | "artist",
+    path: string,
+    language: string = "en-US"
+  ): Promise<void> {
+    debugLog("PlexApi", `Creating library: ${name} (${type}) at ${path}`)
+
+    // Map type to agent and scanner
+    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[0]": path,
+    })
+
+    const response = await fetch(`${this.baseUrl}/library/sections?${params.toString()}`, {
+      method: "POST",
+      headers: this.getHeaders(),
+    })
+
+    if (!response.ok) {
+      const text = await response.text()
+      throw new Error(`Failed to create library: ${response.status} - ${text}`)
+    }
+
+    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")
+  }
+
+  /**
+   * Run the auto-setup process for Plex
+   */
+  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
+    const { env, plexToken } = options
+
+    // Check if server is reachable
+    const healthy = await this.isHealthy()
+    if (!healthy) {
+      return { success: false, message: "Plex server not reachable" }
+    }
+
+    // Check if already claimed
+    try {
+      const serverInfo = await this.getServerInfo()
+      if (serverInfo.claimed) {
+        return {
+          success: true,
+          message: "Already claimed",
+          data: {
+            machineIdentifier: serverInfo.machineIdentifier,
+            version: serverInfo.version,
+          },
+        }
+      }
+    } catch {
+      // Continue with setup if we can't get server info
+    }
+
+    // Get claim token from environment or options
+    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)",
+      }
+    }
+
+    // Store plexToken for future authenticated requests
+    if (plexToken) {
+      this.setToken(plexToken)
+    }
+
+    try {
+      // Claim the server
+      await this.claimServer(claimToken)
+
+      // Get server info after claiming
+      const serverInfo = await this.getServerInfo()
+
+      // Create default libraries if paths exist
+      const libraries = [
+        { name: "Movies", type: "movie" as const, path: "/data/media/movies" },
+        { name: "TV Shows", type: "show" as const, path: "/data/media/tv" },
+        { name: "Music", type: "artist" as const, path: "/data/media/music" },
+      ]
+
+      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) {
+            // Library creation may fail if path doesn't exist - that's OK
+            debugLog("PlexApi", `Could not create library ${lib.name}: ${e}`)
+          }
+        }
+      }
+
+      return {
+        success: true,
+        message: `Server claimed, ${librariesCreated} libraries configured`,
+        data: {
+          machineIdentifier: serverInfo.machineIdentifier,
+          version: serverInfo.version,
+          librariesCreated,
+        },
+      }
+    } catch (error) {
+      return { success: false, message: `${error}` }
+    }
+  }
+}

package/src/api/portainer-api.ts

@@ -5,6 +5,7 @@
 
 import { debugLog } from "../utils/debug"
 import { ensureMinPasswordLength } from "../utils/password"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
 
 // Portainer requires minimum 12 character password
 export const PORTAINER_MIN_PASSWORD_LENGTH = 12
@@ -61,7 +62,7 @@ export interface PortainerApiKeyResponse {
 /**
  * Portainer API Client
  */
-export class PortainerApiClient {
+export class PortainerApiClient implements IAutoSetupClient {
   private baseUrl: string
   private jwtToken: string | null = null
   private apiKey: string | null = null
@@ -346,6 +347,83 @@ export class PortainerApiClient {
       `/endpoints/${endpointId}/docker/containers/${containerId}/stats?stream=false`
     )
   }
+
+  /**
+   * Check if already configured (has admin user)
+   */
+  async isInitialized(): Promise<boolean> {
+    return !(await this.needsInitialization())
+  }
+
+  /**
+   * Run the auto-setup process for Portainer
+   */
+  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
+    const { username, password } = options
+
+    try {
+      // Check if reachable
+      const healthy = await this.isHealthy()
+      if (!healthy) {
+        return { success: false, message: "Portainer not reachable" }
+      }
+
+      // Check if needs initialization
+      const needsInit = await this.needsInitialization()
+
+      let actualPassword = ensureMinPasswordLength(password, PORTAINER_MIN_PASSWORD_LENGTH)
+      let passwordPadded = actualPassword !== password
+      let apiKey: string | undefined
+
+      if (needsInit) {
+        // Initialize admin user
+        const result = await this.initializeAdmin(username, password)
+        if (result) {
+          actualPassword = result.actualPassword
+          passwordPadded = result.passwordWasPadded
+        }
+
+        // Generate API key
+        try {
+          apiKey = await this.generateApiKey(actualPassword)
+        } catch {
+          // API key generation may fail, that's OK
+        }
+      } else {
+        // Login with existing credentials
+        try {
+          await this.login(username, actualPassword)
+        } catch {
+          return { success: false, message: "Login failed - check credentials" }
+        }
+      }
+
+      // Get environment ID
+      const envId = await this.getLocalEnvironmentId()
+
+      return {
+        success: true,
+        message: needsInit
+          ? passwordPadded
+            ? `Admin created (password padded to ${PORTAINER_MIN_PASSWORD_LENGTH} chars)`
+            : "Admin created"
+          : "Logged in",
+        data: {
+          adminCreated: needsInit,
+          passwordPadded,
+          apiKey,
+          environmentId: envId,
+        },
+        envUpdates: {
+          ...(apiKey ? { API_KEY_PORTAINER: apiKey } : {}),
+          ...(envId ? { PORTAINER_ENV: String(envId) } : {}),
+          ...(passwordPadded ? { PASSWORD_PORTAINER: actualPassword } : {}),
+        },
+      }
+    } catch (error) {
+      return { success: false, message: `${error}` }
+    }
+  }
 }
 
 // ==========================================

package/src/api/prowlarr-api.ts

@@ -4,6 +4,7 @@
  */
 
 import { debugLog } from "../utils/debug"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
 
 export interface IndexerProxy {
   id?: number
@@ -67,7 +68,7 @@ export interface Application {
 
 export type ArrAppType = "Radarr" | "Sonarr" | "Lidarr" | "Readarr" | "Whisparr" | "Mylar"
 
-export class ProwlarrClient {
+export class ProwlarrClient implements IAutoSetupClient {
   private baseUrl: string
   private apiKey: string
 
@@ -364,6 +365,48 @@ export class ProwlarrClient {
 
     return this.addApplication(appType, appType, prowlarrUrl, appUrl, apiKey, "fullSync", syncCategories)
   }
+
+  /**
+   * Check if already configured (has any indexers)
+   */
+  async isInitialized(): Promise<boolean> {
+    try {
+      const indexers = await this.getIndexers()
+      return indexers.length > 0
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Run the auto-setup process for Prowlarr
+   */
+  async setup(_options: AutoSetupOptions): Promise<AutoSetupResult> {
+    try {
+      // Check if reachable
+      const healthy = await this.isHealthy()
+      if (!healthy) {
+        return { success: false, message: "Prowlarr not reachable" }
+      }
+
+      // Check current state
+      const indexers = await this.getIndexers()
+      const apps = await this.getApplications()
+      const proxies = await this.getIndexerProxies()
+
+      return {
+        success: true,
+        message: indexers.length > 0 ? "Configured" : "Ready for indexer setup",
+        data: {
+          indexerCount: indexers.length,
+          appCount: apps.length,
+          proxyCount: proxies.length,
+        },
+      }
+    } catch (error) {
+      return { success: false, message: `${error}` }
+    }
+  }
 }
 
 export const PROWLARR_CATEGORIES = [

package/src/api/qbittorrent-api.ts

@@ -5,6 +5,7 @@
  */
 
 import { debugLog } from "../utils/debug"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
 
 export interface QBittorrentPreferences {
   save_path?: string
@@ -20,7 +21,7 @@ export interface QBittorrentCategory {
   savePath: string
 }
 
-export class QBittorrentClient {
+export class QBittorrentClient implements IAutoSetupClient {
   private baseUrl: string
   private username: string
   private password: string
@@ -222,4 +223,59 @@ export class QBittorrentClient {
     }
     debugLog("qBittorrent", "TRaSH configuration complete")
   }
+
+  /**
+   * 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 // 403 means running but not logged in
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Check if already configured (can login)
+   */
+  async isInitialized(): Promise<boolean> {
+    // qBittorrent is always "initialized" - the question is whether we can login
+    return this.isConnected()
+  }
+
+  /**
+   * Run the auto-setup process for qBittorrent
+   */
+  async setup(options: AutoSetupOptions): Promise<AutoSetupResult> {
+    const { username, password } = options
+
+    try {
+      // Check if reachable
+      const healthy = await this.isHealthy()
+      if (!healthy) {
+        return { success: false, message: "qBittorrent not reachable" }
+      }
+
+      // Update credentials and try to login
+      this.username = username
+      this.password = password
+
+      const loggedIn = await this.login()
+      if (!loggedIn) {
+        return { success: false, message: "Login failed - check credentials" }
+      }
+
+      // Configure TRaSH-compliant settings
+      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}` }
+    }
+  }
 }