@muhammedaksam/easiarr 1.1.1 → 1.1.3

package/src/data/lidarr-custom-formats.ts

@@ -0,0 +1,127 @@
+/**
+ * Lidarr Custom Formats (Davo's Community Guide)
+ * Source: https://wiki.servarr.com/lidarr/community-guide
+ *
+ * Unlike Radarr/Sonarr, these are NOT from TRaSH Guides.
+ * Lidarr custom formats use different implementation types.
+ * Uses the same CustomFormat interface from custom-format-api.ts for compatibility.
+ */
+
+import type { CustomFormat } from "../api/custom-format-api"
+
+/**
+ * Preferred Groups - Release groups that are consistently high quality
+ */
+export const CF_PREFERRED_GROUPS: Omit<CustomFormat, "id"> = {
+  name: "Preferred Groups",
+  includeCustomFormatWhenRenaming: false,
+  specifications: [
+    {
+      name: "DeVOiD",
+      implementation: "ReleaseGroupSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bDeVOiD\\b" }],
+    },
+    {
+      name: "PERFECT",
+      implementation: "ReleaseGroupSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bPERFECT\\b" }],
+    },
+    {
+      name: "ENRiCH",
+      implementation: "ReleaseGroupSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bENRiCH\\b" }],
+    },
+  ],
+}
+
+/**
+ * CD - Tag releases that are from CD source
+ */
+export const CF_CD: Omit<CustomFormat, "id"> = {
+  name: "CD",
+  includeCustomFormatWhenRenaming: false,
+  specifications: [
+    {
+      name: "CD",
+      implementation: "ReleaseTitleSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bCD\\b" }],
+    },
+  ],
+}
+
+/**
+ * WEB - Tag releases that are from WEB source
+ */
+export const CF_WEB: Omit<CustomFormat, "id"> = {
+  name: "WEB",
+  includeCustomFormatWhenRenaming: false,
+  specifications: [
+    {
+      name: "WEB",
+      implementation: "ReleaseTitleSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bWEB\\b" }],
+    },
+  ],
+}
+
+/**
+ * Lossless - Tag releases that are lossless (flac/flac24)
+ */
+export const CF_LOSSLESS: Omit<CustomFormat, "id"> = {
+  name: "Lossless",
+  includeCustomFormatWhenRenaming: false,
+  specifications: [
+    {
+      name: "Flac",
+      implementation: "ReleaseTitleSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\blossless\\b" }],
+    },
+  ],
+}
+
+/**
+ * Vinyl - Tag releases that are from Vinyl source
+ */
+export const CF_VINYL: Omit<CustomFormat, "id"> = {
+  name: "Vinyl",
+  includeCustomFormatWhenRenaming: false,
+  specifications: [
+    {
+      name: "Vinyl",
+      implementation: "ReleaseTitleSpecification",
+      negate: false,
+      required: false,
+      fields: [{ name: "value", value: "\\bVinyl\\b" }],
+    },
+  ],
+}
+
+/**
+ * All Lidarr custom formats from Davo's guide
+ */
+export const LIDARR_CUSTOM_FORMATS: Omit<CustomFormat, "id">[] = [
+  CF_PREFERRED_GROUPS,
+  CF_CD,
+  CF_WEB,
+  CF_LOSSLESS,
+  CF_VINYL,
+]
+
+/**
+ * Get all Lidarr custom format names
+ */
+export function getLidarrCFNames(): string[] {
+  return LIDARR_CUSTOM_FORMATS.map((cf) => cf.name)
+}

package/src/data/trash-profiles.ts

@@ -7,7 +7,7 @@ export interface TRaSHProfilePreset {
   id: string
   name: string
   description: string
-  app: "radarr" | "sonarr" | "both"
+  app: "radarr" | "sonarr" | "lidarr" | "both"
   cutoffQuality: string
   allowedQualities: string[]
   cfScores: Record<string, number>
@@ -239,14 +239,88 @@ export const SONARR_PRESETS: TRaSHProfilePreset[] = [
   },
 ]
 
+// Lidarr Quality Names (Davo's Community Guide)
+export const LIDARR_QUALITIES = {
+  FLAC: "FLAC",
+  "FLAC 24bit": "FLAC 24bit",
+  "MP3-320": "MP3-320",
+  "MP3-256": "MP3-256",
+  "MP3-128": "MP3-128",
+}
+
+// Lidarr Custom Format Scores (Davo's Community Guide)
+// Scoring requires minimum 1 to grab, prefers CD > WEB, avoids Vinyl
+export const LIDARR_CF_SCORES = {
+  // Preferred Release Groups
+  "Preferred Groups": 5,
+
+  // Source Preferences
+  CD: 3, // Prefer CD source
+  WEB: 2, // Accept WEB source
+  Lossless: 1, // Tag for lossless
+
+  // Avoid Vinyl (analog noise, pops, clicks)
+  Vinyl: -10000,
+}
+
+// Lidarr Profile Presets (Davo's Community Guide)
+export const LIDARR_PRESETS: TRaSHProfilePreset[] = [
+  {
+    id: "high-quality-flac",
+    name: "High Quality FLAC",
+    description: "FLAC quality with MP3-320 fallback. Prefers CD source, avoids Vinyl.",
+    app: "lidarr",
+    cutoffQuality: "FLAC",
+    allowedQualities: ["FLAC", "FLAC 24bit", "MP3-320"],
+    cfScores: {
+      "Preferred Groups": 5,
+      CD: 3,
+      WEB: 2,
+      Lossless: 1,
+      Vinyl: -10000,
+    },
+  },
+  {
+    id: "flac-only",
+    name: "FLAC Only",
+    description: "Lossless FLAC only, no MP3 fallback. Best quality.",
+    app: "lidarr",
+    cutoffQuality: "FLAC",
+    allowedQualities: ["FLAC", "FLAC 24bit"],
+    cfScores: {
+      "Preferred Groups": 5,
+      CD: 3,
+      WEB: 2,
+      Lossless: 1,
+      Vinyl: -10000,
+    },
+  },
+  {
+    id: "any-quality",
+    name: "Any Quality",
+    description: "Accept any quality including MP3. For maximum availability.",
+    app: "lidarr",
+    cutoffQuality: "MP3-320",
+    allowedQualities: ["FLAC", "FLAC 24bit", "MP3-320", "MP3-256", "MP3-128"],
+    cfScores: {
+      "Preferred Groups": 5,
+      CD: 3,
+      WEB: 2,
+      Lossless: 1,
+      Vinyl: -10000,
+    },
+  },
+]
+
 // Get all presets for an app
-export function getPresetsForApp(app: "radarr" | "sonarr"): TRaSHProfilePreset[] {
+export function getPresetsForApp(app: "radarr" | "sonarr" | "lidarr"): TRaSHProfilePreset[] {
   if (app === "radarr") return RADARR_PRESETS
   if (app === "sonarr") return SONARR_PRESETS
+  if (app === "lidarr") return LIDARR_PRESETS
   return []
 }
 
 // Get a specific preset by ID
 export function getPresetById(id: string): TRaSHProfilePreset | undefined {
-  return [...RADARR_PRESETS, ...SONARR_PRESETS].find((p) => p.id === id)
+  return [...RADARR_PRESETS, ...SONARR_PRESETS, ...LIDARR_PRESETS].find((p) => p.id === id)
 }

package/src/ui/screens/FullAutoSetup.ts

@@ -12,6 +12,7 @@ import { ProwlarrClient, type ArrAppType } from "../../api/prowlarr-api"
 import { QBittorrentClient, type QBittorrentCategory } from "../../api/qbittorrent-api"
 import { PortainerApiClient } from "../../api/portainer-api"
 import { JellyfinClient } from "../../api/jellyfin-api"
+import { QualityProfileClient } from "../../api/quality-profile-api"
 import { JellyseerrClient } from "../../api/jellyseerr-api"
 import { CloudflareApi, setupCloudflaredTunnel } from "../../api/cloudflare-api"
 import { PlexApiClient } from "../../api/plex-api"
@@ -24,11 +25,17 @@ import { HeimdallClient } from "../../api/heimdall-api"
 import { HuntarrClient } from "../../api/huntarr-api"
 import { saveConfig } from "../../config"
 import { saveCompose } from "../../compose"
+import { generateSlskdConfig, getSlskdConfigPath } from "../../config/slskd-config"
+import { generateSoularrConfig, getSoularrConfigPath } from "../../config/soularr-config"
+import { writeFile, mkdir } from "fs/promises"
+import { dirname } from "path"
+import { existsSync } from "fs"
 import { getApp } from "../../apps/registry"
 // import type { AppId } from "../../config/schema"
 import { getCategoriesForApps } from "../../utils/categories"
 import { readEnvSync, updateEnv } from "../../utils/env"
 import { debugLog } from "../../utils/debug"
+import { getApplicationUrl } from "../../utils/url-utils"
 
 interface SetupStep {
   name: string
@@ -90,7 +97,10 @@ export class FullAutoSetup extends BoxRenderable {
   private initSteps(): void {
     this.steps = [
       { name: "Root Folders", status: "pending" },
+      { name: "Naming Scheme", status: "pending" },
+      { name: "Quality Settings", status: "pending" },
       { name: "Authentication", status: "pending" },
+      { name: "External URLs", status: "pending" },
       { name: "Prowlarr Apps", status: "pending" },
       { name: "FlareSolverr", status: "pending" },
       { name: "qBittorrent", status: "pending" },
@@ -106,6 +116,8 @@ export class FullAutoSetup extends BoxRenderable {
       { name: "Homarr", status: "pending" },
       { name: "Heimdall", status: "pending" },
       { name: "Huntarr", status: "pending" },
+      { name: "Slskd", status: "pending" },
+      { name: "Soularr", status: "pending" },
       { name: "Cloudflare Tunnel", status: "pending" },
     ]
   }
@@ -140,55 +152,70 @@ export class FullAutoSetup extends BoxRenderable {
     // Step 1: Root folders
     await this.setupRootFolders()
 
-    // Step 2: Authentication
+    // Step 2: Naming Scheme
+    await this.setupNaming()
+
+    // Step 2b: Quality Settings
+    await this.setupQuality()
+
+    // Step 3: Authentication
     await this.setupAuthentication()
 
-    // Step 3: Prowlarr apps
+    // Step 3: External URLs
+    await this.setupExternalUrls()
+
+    // Step 4: Prowlarr apps
     await this.setupProwlarrApps()
 
-    // Step 4: FlareSolverr
+    // Step 5: FlareSolverr
     await this.setupFlareSolverr()
 
-    // Step 5: qBittorrent
+    // Step 6: qBittorrent
     await this.setupQBittorrent()
 
-    // Step 6: Portainer
+    // Step 7: Portainer
     await this.setupPortainer()
 
-    // Step 7: Jellyfin
+    // Step 8: Jellyfin
     await this.setupJellyfin()
 
-    // Step 8: Jellyseerr
+    // Step 9: Jellyseerr
     await this.setupJellyseerr()
 
-    // Step 9: Plex
+    // Step 10: Plex
     await this.setupPlex()
 
-    // Step 10: Overseerr (requires Plex)
+    // Step 11: Overseerr (requires Plex)
     await this.setupOverseerr()
 
-    // Step 11: Tautulli (Plex monitoring)
+    // Step 12: Tautulli (Plex monitoring)
     await this.setupTautulli()
 
-    // Step 12: Bazarr (subtitles)
+    // Step 13: Bazarr (subtitles)
     await this.setupBazarr()
 
-    // Step 13: Uptime Kuma (monitors)
+    // Step 14: Uptime Kuma (monitors)
     await this.setupUptimeKuma()
 
-    // Step 14: Grafana (dashboards)
+    // Step 15: Grafana (dashboards)
     await this.setupGrafana()
 
-    // Step 15: Homarr (dashboard)
+    // Step 16: Homarr (dashboard)
     await this.setupHomarr()
 
-    // Step 16: Heimdall (dashboard)
+    // Step 17: Heimdall (dashboard)
     await this.setupHeimdall()
 
-    // Step 17: Huntarr (*arr app manager)
+    // Step 18: Huntarr (*arr app manager)
     await this.setupHuntarr()
 
-    // Step 18: Cloudflare Tunnel
+    // Step 19: Slskd (Soulseek client)
+    await this.setupSlskd()
+
+    // Step 20: Soularr (Lidarr -> Slskd bridge)
+    await this.setupSoularr()
+
+    // Step 21: Cloudflare Tunnel
     await this.setupCloudflare()
 
     this.isRunning = false
@@ -235,6 +262,74 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupNaming(): Promise<void> {
+    this.updateStep("Naming Scheme", "running")
+    this.refreshContent()
+
+    try {
+      const arrApps = this.config.apps.filter((a) => {
+        return a.enabled && (a.id === "radarr" || a.id === "sonarr")
+      })
+
+      for (const app of arrApps) {
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) continue
+
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const port = app.port || def.defaultPort
+        const client = new ArrApiClient("localhost", port, apiKey, def.rootFolder?.apiVersion || "v3")
+
+        try {
+          await client.configureTRaSHNaming(app.id as "radarr" | "sonarr")
+          debugLog("FullAutoSetup", `Configured naming for ${app.id}`)
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to configure naming for ${app.id}: ${e}`)
+        }
+      }
+
+      this.updateStep("Naming Scheme", "success")
+    } catch (e) {
+      this.updateStep("Naming Scheme", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
+  private async setupQuality(): Promise<void> {
+    this.updateStep("Quality Settings", "running")
+    this.refreshContent()
+
+    try {
+      const arrApps = this.config.apps.filter((a) => {
+        return a.enabled && (a.id === "radarr" || a.id === "sonarr")
+      })
+
+      for (const app of arrApps) {
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) continue
+
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const port = app.port || def.defaultPort
+        const client = new QualityProfileClient("localhost", port, apiKey)
+
+        try {
+          await client.updateTrashQualityDefinitions(app.id as "radarr" | "sonarr")
+          debugLog("FullAutoSetup", `Configured quality settings for ${app.id}`)
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to configure quality settings for ${app.id}: ${e}`)
+        }
+      }
+
+      this.updateStep("Quality Settings", "success")
+    } catch (e) {
+      this.updateStep("Quality Settings", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private async setupAuthentication(): Promise<void> {
     this.updateStep("Authentication", "running")
     this.refreshContent()
@@ -317,6 +412,10 @@ export class FullAutoSetup extends BoxRenderable {
               debugLog("FullAutoSetup", "Failed to configure Bazarr -> Sonarr connection")
             }
           }
+
+          // TRaSH Recommended Settings
+          await bazarrClient.configureGeneralSettings()
+          await bazarrClient.configureDefaultLanguageProfile()
         }
       }
 
@@ -327,6 +426,56 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupExternalUrls(): Promise<void> {
+    this.updateStep("External URLs", "running")
+    this.refreshContent()
+
+    let configured = 0
+
+    try {
+      // Configure *arr apps (Radarr, Sonarr, Lidarr, Readarr, Whisparr, Prowlarr)
+      const arrApps = this.config.apps.filter((a) => {
+        const def = getApp(a.id)
+        return a.enabled && (def?.rootFolder || a.id === "prowlarr")
+      })
+
+      for (const app of arrApps) {
+        const def = getApp(app.id)
+        if (!def) continue
+
+        const apiKey = this.env[`API_KEY_${app.id.toUpperCase()}`]
+        if (!apiKey) {
+          continue
+        }
+
+        const port = app.port || def.defaultPort
+        const apiVersion = app.id === "prowlarr" ? "v1" : def.rootFolder?.apiVersion || "v3"
+        const client = new ArrApiClient("localhost", port, apiKey, apiVersion)
+
+        try {
+          const applicationUrl = getApplicationUrl(app.id, port, this.config)
+          await client.setApplicationUrl(applicationUrl)
+          debugLog("FullAutoSetup", `Set applicationUrl for ${app.id}: ${applicationUrl}`)
+          configured++
+        } catch (e) {
+          debugLog("FullAutoSetup", `Failed to set applicationUrl for ${app.id}: ${e}`)
+        }
+      }
+
+      // Note: Jellyseerr and Overseerr are handled in their own setup steps
+      // (setupJellyseerr/setupOverseerr) because they require authentication first
+
+      if (configured > 0) {
+        this.updateStep("External URLs", "success", `${configured} apps configured`)
+      } else {
+        this.updateStep("External URLs", "skipped", "No apps with API keys")
+      }
+    } catch (e) {
+      this.updateStep("External URLs", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private async setupProwlarrApps(): Promise<void> {
     this.updateStep("Prowlarr Apps", "running")
     this.refreshContent()
@@ -581,12 +730,16 @@ export class FullAutoSetup extends BoxRenderable {
         if (radarrConfig && this.env["API_KEY_RADARR"]) {
           try {
             const radarrDef = getApp("radarr")
+            const radarrPort = radarrConfig.port || radarrDef?.defaultPort || 7878
+            const radarrExternalUrl = getApplicationUrl("radarr", radarrPort, this.config)
             await client.configureRadarr(
               "radarr",
-              radarrConfig.port || radarrDef?.defaultPort || 7878,
+              radarrPort,
               this.env["API_KEY_RADARR"],
-              radarrDef?.rootFolder?.path || "/data/media/movies"
+              radarrDef?.rootFolder?.path || "/data/media/movies",
+              radarrExternalUrl
             )
+            debugLog("FullAutoSetup", `Jellyseerr: Radarr externalUrl set to ${radarrExternalUrl}`)
           } catch {
             /* Radarr config failed */
           }
@@ -596,17 +749,43 @@ export class FullAutoSetup extends BoxRenderable {
         if (sonarrConfig && this.env["API_KEY_SONARR"]) {
           try {
             const sonarrDef = getApp("sonarr")
+            const sonarrPort = sonarrConfig.port || sonarrDef?.defaultPort || 8989
+            const sonarrExternalUrl = getApplicationUrl("sonarr", sonarrPort, this.config)
             await client.configureSonarr(
               "sonarr",
-              sonarrConfig.port || sonarrDef?.defaultPort || 8989,
+              sonarrPort,
               this.env["API_KEY_SONARR"],
-              sonarrDef?.rootFolder?.path || "/data/media/tv"
+              sonarrDef?.rootFolder?.path || "/data/media/tv",
+              sonarrExternalUrl
             )
+            debugLog("FullAutoSetup", `Jellyseerr: Sonarr externalUrl set to ${sonarrExternalUrl}`)
           } catch {
             /* Sonarr config failed */
           }
         }
 
+        // Set Jellyfin's externalHostname for navigation links
+        const jellyfinConfig = this.config.apps.find((a) => a.id === "jellyfin" && a.enabled)
+        if (jellyfinConfig) {
+          try {
+            const jellyfinPort = jellyfinConfig.port || 8096
+            const jellyfinUrl = getApplicationUrl("jellyfin", jellyfinPort, this.config)
+            await client.updateJellyfinSettings({ externalHostname: jellyfinUrl })
+            debugLog("FullAutoSetup", `Jellyseerr: Jellyfin externalHostname set to ${jellyfinUrl}`)
+          } catch {
+            debugLog("FullAutoSetup", "Failed to set Jellyfin externalHostname in Jellyseerr")
+          }
+        }
+
+        // Set Jellyseerr's own applicationUrl (we're already authenticated from setup)
+        try {
+          const jellyseerrUrl = getApplicationUrl("jellyseerr", port, this.config)
+          await client.setApplicationUrl(jellyseerrUrl)
+          debugLog("FullAutoSetup", `Jellyseerr: applicationUrl set to ${jellyseerrUrl}`)
+        } catch {
+          debugLog("FullAutoSetup", "Failed to set Jellyseerr applicationUrl")
+        }
+
         this.updateStep("Jellyseerr", "success", result.message)
       } else {
         this.updateStep("Jellyseerr", "skipped", result.message)
@@ -874,6 +1053,16 @@ export class FullAutoSetup extends BoxRenderable {
           await updateEnv(result.envUpdates)
           Object.assign(this.env, result.envUpdates)
         }
+
+        // Set Overseerr's applicationUrl (we're already authenticated from setup)
+        try {
+          const overseerrUrl = getApplicationUrl("overseerr", port, this.config)
+          await client.setApplicationUrl(overseerrUrl)
+          debugLog("FullAutoSetup", `Overseerr: applicationUrl set to ${overseerrUrl}`)
+        } catch {
+          debugLog("FullAutoSetup", "Failed to set Overseerr applicationUrl")
+        }
+
         this.updateStep("Overseerr", "success", result.message)
       } else {
         this.updateStep("Overseerr", "skipped", result.message)
@@ -1108,6 +1297,92 @@ export class FullAutoSetup extends BoxRenderable {
     this.refreshContent()
   }
 
+  private async setupSlskd(): Promise<void> {
+    this.updateStep("Slskd", "running")
+    this.refreshContent()
+
+    const slskdConfig = this.config.apps.find((a) => a.id === "slskd" && a.enabled)
+    if (!slskdConfig) {
+      this.updateStep("Slskd", "skipped", "Not enabled")
+      this.refreshContent()
+      return
+    }
+
+    try {
+      // Generate slskd.yml config with auto-generated API key
+      const { yaml, apiKey } = generateSlskdConfig(this.config)
+      const configPath = getSlskdConfigPath(this.config.rootDir)
+
+      // Ensure config directory exists
+      const configDir = dirname(configPath)
+      if (!existsSync(configDir)) {
+        await mkdir(configDir, { recursive: true })
+      }
+
+      // Create slskd download directories (like qBittorrent categories)
+      const slskdDownloadsDir = `${this.config.rootDir}/data/slskd_downloads`
+      await mkdir(`${slskdDownloadsDir}/incomplete`, { recursive: true })
+      await mkdir(`${slskdDownloadsDir}/complete`, { recursive: true })
+      debugLog("FullAutoSetup", `Created slskd download directories at ${slskdDownloadsDir}`)
+
+      // Always write slskd.yml - Docker creates a commented-out example that we need to replace
+      await writeFile(configPath, yaml)
+      debugLog("FullAutoSetup", `Generated slskd.yml at ${configPath}`)
+
+      // Save API key to .env for Homepage widget and Soularr
+      await updateEnv({ API_KEY_SLSKD: apiKey })
+      this.env["API_KEY_SLSKD"] = apiKey
+
+      this.updateStep("Slskd", "success", "Config generated, API key saved")
+    } catch (e) {
+      this.updateStep("Slskd", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
+  private async setupSoularr(): Promise<void> {
+    this.updateStep("Soularr", "running")
+    this.refreshContent()
+
+    const soularrConfig = this.config.apps.find((a) => a.id === "soularr" && a.enabled)
+    if (!soularrConfig) {
+      this.updateStep("Soularr", "skipped", "Not enabled")
+      this.refreshContent()
+      return
+    }
+
+    // Check dependencies
+    const lidarrConfig = this.config.apps.find((a) => a.id === "lidarr" && a.enabled)
+    const slskdConfig = this.config.apps.find((a) => a.id === "slskd" && a.enabled)
+
+    if (!lidarrConfig || !slskdConfig) {
+      this.updateStep("Soularr", "skipped", "Requires Lidarr & Slskd")
+      this.refreshContent()
+      return
+    }
+
+    try {
+      // Generate soularr config.ini
+      const configContent = generateSoularrConfig(this.config)
+      const configPath = getSoularrConfigPath(this.config.rootDir)
+
+      // Ensure directory exists
+      const configDir = dirname(configPath)
+      if (!existsSync(configDir)) {
+        await mkdir(configDir, { recursive: true })
+      }
+
+      // Write config file
+      await writeFile(configPath, configContent)
+      debugLog("FullAutoSetup", `Generated soularr config at ${configPath}`)
+
+      this.updateStep("Soularr", "success", "Config generated")
+    } catch (e) {
+      this.updateStep("Soularr", "error", `${e}`)
+    }
+    this.refreshContent()
+  }
+
   private updateStep(name: string, status: SetupStep["status"], message?: string): void {
     const step = this.steps.find((s) => s.name === name)
     if (step) {