@muhammedaksam/easiarr 1.0.0 → 1.1.1

package/src/api/grafana-api.ts

@@ -0,0 +1,314 @@
+/**
+ * Grafana API Client
+ * Handles Grafana auto-setup including admin password change and Prometheus datasource
+ */
+
+import { debugLog } from "../utils/debug"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
+
+interface GrafanaDataSource {
+  id?: number
+  uid?: string
+  orgId?: number
+  name: string
+  type: string
+  access: string
+  url: string
+  isDefault?: boolean
+  jsonData?: Record<string, unknown>
+  secureJsonData?: Record<string, unknown>
+}
+
+interface GrafanaHealthResponse {
+  commit: string
+  database: string
+  version: string
+}
+
+export class GrafanaClient implements IAutoSetupClient {
+  private host: string
+  private port: number
+  private username: string
+  private password: string
+
+  constructor(host: string, port: number = 3000, username: string = "admin", password: string = "admin") {
+    this.host = host
+    this.port = port
+    this.username = username
+    this.password = password
+  }
+
+  /**
+   * Get base URL for Grafana
+   */
+  private get baseUrl(): string {
+    return `http://${this.host}:${this.port}`
+  }
+
+  /**
+   * Get Basic Auth header
+   */
+  private getAuthHeader(): string {
+    const credentials = Buffer.from(`${this.username}:${this.password}`).toString("base64")
+    return `Basic ${credentials}`
+  }
+
+  /**
+   * Common headers for Grafana API requests
+   */
+  private getHeaders(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: this.getAuthHeader(),
+    }
+  }
+
+  /**
+   * Update credentials (after password change)
+   */
+  setCredentials(username: string, password: string): void {
+    this.username = username
+    this.password = password
+  }
+
+  /**
+   * Check if Grafana is reachable
+   */
+  async isHealthy(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/health`, {
+        method: "GET",
+      })
+      debugLog("GrafanaApi", `Health check: ${response.status}`)
+      return response.ok
+    } catch (error) {
+      debugLog("GrafanaApi", `Health check failed: ${error}`)
+      return false
+    }
+  }
+
+  /**
+   * Check if Grafana is already configured (has non-default password)
+   */
+  async isInitialized(): Promise<boolean> {
+    try {
+      // Try to login with default credentials
+      const response = await fetch(`${this.baseUrl}/api/user`, {
+        method: "GET",
+        headers: {
+          Authorization: `Basic ${Buffer.from("admin:admin").toString("base64")}`,
+        },
+      })
+      // If login with admin:admin fails, it's already configured
+      return !response.ok
+    } catch {
+      return true
+    }
+  }
+
+  /**
+   * Change admin password
+   */
+  async changeAdminPassword(newPassword: string): Promise<boolean> {
+    debugLog("GrafanaApi", "Changing admin password...")
+
+    const response = await fetch(`${this.baseUrl}/api/user/password`, {
+      method: "PUT",
+      headers: this.getHeaders(),
+      body: JSON.stringify({
+        oldPassword: this.password,
+        newPassword: newPassword,
+      }),
+    })
+
+    if (response.ok) {
+      debugLog("GrafanaApi", "Admin password changed successfully")
+      this.password = newPassword
+      return true
+    }
+
+    const text = await response.text()
+    debugLog("GrafanaApi", `Failed to change password: ${response.status} - ${text}`)
+    return false
+  }
+
+  /**
+   * Get list of datasources
+   */
+  async getDataSources(): Promise<GrafanaDataSource[]> {
+    const response = await fetch(`${this.baseUrl}/api/datasources`, {
+      method: "GET",
+      headers: this.getHeaders(),
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to get datasources: ${response.status}`)
+    }
+
+    return response.json()
+  }
+
+  /**
+   * Check if a datasource with the given name exists
+   */
+  async dataSourceExists(name: string): Promise<boolean> {
+    const dataSources = await this.getDataSources()
+    return dataSources.some((ds) => ds.name === name)
+  }
+
+  /**
+   * Create a Prometheus datasource
+   */
+  async createPrometheusDataSource(
+    name: string = "Prometheus",
+    url: string = "http://prometheus:9090",
+    isDefault: boolean = true
+  ): Promise<boolean> {
+    debugLog("GrafanaApi", `Creating Prometheus datasource: ${name} -> ${url}`)
+
+    const payload: GrafanaDataSource = {
+      name,
+      type: "prometheus",
+      access: "proxy",
+      url,
+      isDefault,
+      jsonData: {
+        httpMethod: "POST",
+        timeInterval: "15s",
+      },
+    }
+
+    const response = await fetch(`${this.baseUrl}/api/datasources`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(payload),
+    })
+
+    if (response.ok) {
+      debugLog("GrafanaApi", `Prometheus datasource "${name}" created successfully`)
+      return true
+    }
+
+    // Check if already exists (409 Conflict)
+    if (response.status === 409) {
+      debugLog("GrafanaApi", `Datasource "${name}" already exists`)
+      return true
+    }
+
+    const text = await response.text()
+    debugLog("GrafanaApi", `Failed to create datasource: ${response.status} - ${text}`)
+    return false
+  }
+
+  /**
+   * Generate an API key for external integrations
+   */
+  async createApiKey(name: string = "easiarr", role: string = "Admin"): Promise<string | null> {
+    debugLog("GrafanaApi", `Creating API key: ${name}`)
+
+    const response = await fetch(`${this.baseUrl}/api/auth/keys`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({
+        name,
+        role,
+        secondsToLive: 0, // Never expires
+      }),
+    })
+
+    if (response.ok) {
+      const data = await response.json()
+      debugLog("GrafanaApi", "API key created successfully")
+      return data.key
+    }
+
+    // May already exist
+    if (response.status === 409) {
+      debugLog("GrafanaApi", "API key already exists")
+      return null
+    }
+
+    const text = await response.text()
+    debugLog("GrafanaApi", `Failed to create API key: ${response.status} - ${text}`)
+    return null
+  }
+
+  /**
+   * Get Grafana server info
+   */
+  async getServerInfo(): Promise<GrafanaHealthResponse | null> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/health`, {
+        method: "GET",
+      })
+
+      if (response.ok) {
+        return response.json()
+      }
+    } catch {
+      // Ignore
+    }
+    return null
+  }
+
+  /**
+   * Run the auto-setup process for Grafana
+   */
+  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: "Grafana not reachable" }
+      }
+
+      // Check if already configured
+      const initialized = await this.isInitialized()
+
+      if (!initialized) {
+        // First login - change default password
+        this.setCredentials("admin", "admin")
+
+        const changed = await this.changeAdminPassword(password)
+        if (!changed) {
+          return { success: false, message: "Failed to change admin password" }
+        }
+      } else {
+        // Try to login with provided credentials
+        this.setCredentials(username, password)
+
+        // Verify login by fetching user
+        const response = await fetch(`${this.baseUrl}/api/user`, {
+          method: "GET",
+          headers: this.getHeaders(),
+        })
+
+        if (!response.ok) {
+          return { success: false, message: "Login failed - check credentials" }
+        }
+      }
+
+      // Now configure Prometheus datasource if prometheus is enabled
+      // Use container name for internal communication
+      const prometheusExists = await this.dataSourceExists("Prometheus")
+      if (!prometheusExists) {
+        await this.createPrometheusDataSource("Prometheus", "http://prometheus:9090", true)
+      }
+
+      // Generate API key for Homepage widget etc.
+      const apiKey = await this.createApiKey("easiarr-api-key")
+
+      return {
+        success: true,
+        message: initialized ? "Configured" : "Password changed, Prometheus added",
+        data: apiKey ? { apiKey } : undefined,
+        envUpdates: apiKey ? { API_KEY_GRAFANA: apiKey } : undefined,
+      }
+    } catch (error) {
+      return { success: false, message: `${error}` }
+    }
+  }
+}

package/src/api/heimdall-api.ts

@@ -0,0 +1,209 @@
+/**
+ * Heimdall API Client
+ * Handles Heimdall dashboard auto-setup with application tiles
+ */
+
+import { debugLog } from "../utils/debug"
+import type { IAutoSetupClient, AutoSetupOptions, AutoSetupResult } from "./auto-setup-types"
+import type { AppConfig } from "../config/schema"
+import { getApp } from "../apps/registry"
+
+interface HeimdallApp {
+  id?: number
+  title: string
+  url: string
+  colour?: string
+  icon?: string
+  appdescription?: string
+  pinned?: boolean
+}
+
+export class HeimdallClient implements IAutoSetupClient {
+  private host: string
+  private port: number
+
+  constructor(host: string, port: number = 80) {
+    this.host = host
+    this.port = port
+  }
+
+  /**
+   * Get base URL for Heimdall
+   */
+  private get baseUrl(): string {
+    return `http://${this.host}:${this.port}`
+  }
+
+  /**
+   * Check if Heimdall is reachable
+   */
+  async isHealthy(): Promise<boolean> {
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "GET",
+      })
+      debugLog("HeimdallApi", `Health check: ${response.status}`)
+      return response.ok
+    } catch (error) {
+      debugLog("HeimdallApi", `Health check failed: ${error}`)
+      return false
+    }
+  }
+
+  /**
+   * Check if already configured
+   */
+  async isInitialized(): Promise<boolean> {
+    // Heimdall is always "initialized" - it works out of the box
+    return true
+  }
+
+  /**
+   * Get list of apps (via API if available)
+   * Note: Heimdall primarily uses web UI for configuration
+   */
+  async getApps(): Promise<HeimdallApp[]> {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/items`, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+        },
+      })
+
+      if (response.ok) {
+        return response.json()
+      }
+    } catch {
+      // API may not be available or require auth
+    }
+    return []
+  }
+
+  /**
+   * Add an app/tile to Heimdall
+   * Note: Heimdall API may require authentication
+   */
+  async addApp(app: HeimdallApp): Promise<boolean> {
+    debugLog("HeimdallApi", `Adding app: ${app.title}`)
+
+    try {
+      const response = await fetch(`${this.baseUrl}/api/items`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify(app),
+      })
+
+      if (response.ok) {
+        debugLog("HeimdallApi", `App "${app.title}" added successfully`)
+        return true
+      }
+
+      // API might require auth or not exist
+      if (response.status === 401 || response.status === 403) {
+        debugLog("HeimdallApi", "API requires authentication")
+        return false
+      }
+
+      if (response.status === 404) {
+        debugLog("HeimdallApi", "Items API not available")
+        return false
+      }
+
+      const text = await response.text()
+      debugLog("HeimdallApi", `Failed to add app: ${response.status} - ${text}`)
+      return false
+    } catch (error) {
+      debugLog("HeimdallApi", `Failed to add app: ${error}`)
+      return false
+    }
+  }
+
+  /**
+   * Build app config for an easiarr app
+   */
+  buildAppConfig(appConfig: AppConfig): HeimdallApp | null {
+    const appDef = getApp(appConfig.id)
+    if (!appDef) return null
+
+    // Skip apps without web UI
+    if (appDef.defaultPort === 0) return null
+
+    const port = appConfig.port || appDef.defaultPort
+
+    return {
+      title: appDef.name,
+      url: `http://${appConfig.id}:${port}`,
+      appdescription: appDef.description,
+      pinned: true,
+      colour: this.getColorForCategory(appDef.category),
+    }
+  }
+
+  /**
+   * Get a color based on app category
+   */
+  private getColorForCategory(category: string): string {
+    const colors: Record<string, string> = {
+      servarr: "#ffc107",
+      indexer: "#17a2b8",
+      downloader: "#28a745",
+      mediaserver: "#6c5ce7",
+      request: "#e17055",
+      monitoring: "#00cec9",
+      infrastructure: "#636e72",
+      vpn: "#fd79a8",
+      utility: "#74b9ff",
+    }
+    return colors[category] || "#6c757d"
+  }
+
+  /**
+   * Run the auto-setup process for Heimdall
+   */
+  async setup(_options: AutoSetupOptions): Promise<AutoSetupResult> {
+    try {
+      // Check if reachable
+      const healthy = await this.isHealthy()
+      if (!healthy) {
+        return { success: false, message: "Heimdall not reachable" }
+      }
+
+      // Check existing apps count
+      const existingApps = await this.getApps()
+
+      // Heimdall works out of the box, tiles can be added via UI
+      return {
+        success: true,
+        message: "Ready - add tiles via UI",
+        data: { existingAppsCount: existingApps.length },
+      }
+    } catch (error) {
+      return { success: false, message: `${error}` }
+    }
+  }
+
+  /**
+   * Auto-add apps for enabled easiarr services
+   */
+  async setupEasiarrApps(apps: AppConfig[]): Promise<number> {
+    let addedCount = 0
+
+    for (const appConfig of apps) {
+      if (!appConfig.enabled) continue
+
+      const heimdallApp = this.buildAppConfig(appConfig)
+      if (!heimdallApp) continue
+
+      const success = await this.addApp(heimdallApp)
+      if (success) {
+        addedCount++
+      }
+    }
+
+    return addedCount
+  }
+}