goblin-malin 0.1.13 → 0.1.14

package/dist/{chunk-OUQ2CB5Q.js → chunk-5KBWKKXR.js}

@@ -10,7 +10,7 @@ import {
   getCacheDir,
   globalLogger,
   inkTransport
-} from "./chunk-4NSWYXSP.js";
+} from "./chunk-QSUGRYOC.js";
 
 // src/index.tsx
 import React70 from "react";
@@ -1246,6 +1246,48 @@ var Env = class {
     }
   }
   async getVariablesWithWizard(config) {
+    if (config.modes && config.modeEnvVar) {
+      const modeEnvVar = config.modeEnvVar;
+      const chosenModeId = process.env[modeEnvVar] ?? config.modes[0].id;
+      const activeMode = config.modes.find((m) => m.id === chosenModeId) ?? config.modes[0];
+      const missingModeFields = activeMode.fields.filter((f) => !process.env[f.envVar]);
+      if (missingModeFields.length === 0) {
+        return {
+          [modeEnvVar]: activeMode.id,
+          ...Object.fromEntries(activeMode.fields.map((f) => [
+            f.envVar,
+            process.env[f.envVar]
+          ]))
+        };
+      }
+      let values;
+      try {
+        values = await this.task.getPrompt().askSetupWizard(config);
+      } catch (error) {
+        this.persistProviderDisabled(config);
+        throw error;
+      }
+      const nonEmpty = Object.fromEntries(Object.entries(values).filter(([, v]) => v.trim()));
+      try {
+        if (config.envSection && Object.keys(nonEmpty).length > 0) {
+          await saveEnvVarsGroup(nonEmpty, config.envSection);
+        } else {
+          for (const [key, value] of Object.entries(nonEmpty)) {
+            await saveEnvVar(key, value);
+          }
+        }
+        this.logger.info(`Saved wizard vars to .env file.`);
+      } catch (error) {
+        this.logger.error(`Failed to save wizard vars to .env file:`, {
+          error
+        });
+        throw new Error(`Could not persist environment variables to .env file`);
+      }
+      for (const [key, value] of Object.entries(values)) {
+        process.env[key] = value;
+      }
+      return values;
+    }
     const missing = config.fields.filter((f) => !process.env[f.envVar]);
     if (missing.length > 0) {
       let values;
@@ -1561,6 +1603,13 @@ var BUILTIN_PROVIDERS = {
     color: "#f76c1b",
     colorSubtle: "#7a3000",
     colorBright: "#ff8c3a"
+  },
+  spotifyUrlInfo: {
+    label: "Scraped",
+    acronym: "SCRAPED SPOTIFY",
+    color: "#3bb0a0",
+    colorSubtle: "#0f5a52",
+    colorBright: "#56d4c4"
   }
 };
 var FALLBACK = {
@@ -2273,6 +2322,144 @@ var MetadataService = class extends ServiceBase {
   }
 };
 
+// src/flows/musicDownloadFlow/services/apis/spotify-url-info-client.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var createSpotifyUrlInfo = require2("spotify-url-info");
+var api = createSpotifyUrlInfo(fetch);
+function getSpotifyEmbedDetails(url) {
+  return api.getDetails(url);
+}
+__name(getSpotifyEmbedDetails, "getSpotifyEmbedDetails");
+
+// src/flows/musicDownloadFlow/services/metadata-providers/spotify/convertSpotifyUrlInfoToTrack.ts
+function parseArtistNames(artistName) {
+  if (!artistName) return [];
+  return artistName.split(/,|&|\bfeat\.?\b|\bft\.?\b/i).map((n) => n.trim()).filter((n) => n.length > 0).map((name) => ({
+    type: "artist",
+    name
+  }));
+}
+__name(parseArtistNames, "parseArtistNames");
+function extractTrackId(url) {
+  try {
+    const parsed = new URL(url);
+    const trackMatch = parsed.pathname.match(/\/(?:intl-[a-z]{2}\/)?track\/([a-zA-Z0-9]+)/);
+    return trackMatch ? trackMatch[1] : null;
+  } catch {
+    return null;
+  }
+}
+__name(extractTrackId, "extractTrackId");
+function convertSpotifyUrlInfoToTrack(url, details, options = {}) {
+  const track = details.tracks[0];
+  const id = extractTrackId(url) ?? track.uri?.split(":").pop() ?? "";
+  return {
+    id,
+    trackName: track.name,
+    artists: parseArtistNames(track.artist),
+    duration: track.duration,
+    url,
+    uri: `SPOTIFY::TRACK::${id}`,
+    nativeAppUriDesktop: `spotify:track:${id}`,
+    platform: "spotify",
+    apiProvider: options.isFallback ? "spotify" : "spotifyUrlInfo",
+    fetchedBy: "spotifyUrlInfo",
+    fetchedAt: /* @__PURE__ */ new Date(),
+    type: "track"
+  };
+}
+__name(convertSpotifyUrlInfoToTrack, "convertSpotifyUrlInfoToTrack");
+
+// src/flows/musicDownloadFlow/saveSettings.ts
+import fs3 from "fs";
+
+// src/flows/musicDownloadFlow/settings.ts
+import * as os from "os";
+import * as path2 from "path";
+function extractProviderDefaults(registry) {
+  const result = {};
+  for (const key of registry.getFactories().keys()) {
+    const schema = registry.getConstructor(key)?.defaultSettings;
+    result[key] = schema ? Object.fromEntries(Object.entries(schema).map(([k, v]) => [
+      k,
+      v.defaultValue
+    ])) : {
+      enabled: true
+    };
+  }
+  return result;
+}
+__name(extractProviderDefaults, "extractProviderDefaults");
+function getPlatformDefaultMusicOutputDir() {
+  switch (process.platform) {
+    case "win32":
+      return path2.join(os.homedir(), "Music", "GoblinMalin");
+    case "darwin":
+      return path2.join(os.homedir(), "Music", "GoblinMalin");
+    default:
+      return path2.join(process.env.XDG_MUSIC_DIR ?? path2.join(os.homedir(), "Music"), "GoblinMalin");
+  }
+}
+__name(getPlatformDefaultMusicOutputDir, "getPlatformDefaultMusicOutputDir");
+var MEDIA_OUTPUT_DIR = getPlatformDefaultMusicOutputDir();
+var BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS = {
+  metadata: {
+    autoChooseBestSource: false,
+    providers: {},
+    discoveryProviders: {}
+  },
+  download: {
+    autoChooseBestSource: false,
+    autoSaveToOutputDir: true,
+    autoDeleteTempAfter24h: false,
+    autoRelocateMissingFiles: false,
+    outputDir: MEDIA_OUTPUT_DIR,
+    outputTemporaryDir: path2.join(MEDIA_OUTPUT_DIR, "tmp"),
+    providers: {}
+  },
+  ui: {
+    columnRatios: {}
+  }
+};
+
+// src/flows/musicDownloadFlow/saveSettings.ts
+function getFlowSettings() {
+  return SettingsStore.getInstance().getFlowSettings("music-downloader", BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS);
+}
+__name(getFlowSettings, "getFlowSettings");
+function getTempDownloadDir() {
+  return getFlowSettings().download.outputTemporaryDir;
+}
+__name(getTempDownloadDir, "getTempDownloadDir");
+function getDownloadProviderSettings(providerKey) {
+  return getFlowSettings().download.providers[providerKey] ?? {};
+}
+__name(getDownloadProviderSettings, "getDownloadProviderSettings");
+function getMetadataProviderSettings(providerKey) {
+  return getFlowSettings().metadata.providers[providerKey] ?? {};
+}
+__name(getMetadataProviderSettings, "getMetadataProviderSettings");
+function clearTempDownloads() {
+  const dir = getTempDownloadDir();
+  if (fs3.existsSync(dir)) {
+    fs3.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+  }
+  globalLogger.info("Temporary downloads cleared");
+}
+__name(clearTempDownloads, "clearTempDownloads");
+function getSaveSettings() {
+  const s = getFlowSettings();
+  return {
+    outputDir: s.download.outputDir,
+    includeMusicBrainzTags: false
+  };
+}
+__name(getSaveSettings, "getSaveSettings");
+
 // src/flows/musicDownloadFlow/services/metadata-providers/spotify/SpotifyService.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -2301,6 +2488,11 @@ var SpotifyService = class _SpotifyService extends MetadataService {
       label: "Enable",
       defaultValue: true,
       kind: "checkbox"
+    },
+    fallbackToWeb: {
+      label: "Fallback on Spotify Web if API is unavailable",
+      defaultValue: true,
+      kind: "checkbox"
     }
   };
   static setupWizard = {
@@ -2311,61 +2503,87 @@ var SpotifyService = class _SpotifyService extends MetadataService {
       name: "SPOTIFY",
       url: "https://developer.spotify.com/dashboard"
     },
-    description: [
-      {
-        type: "note",
-        text: "You need a Premium Spotify Account to access the Spotify API."
-      },
-      {
-        type: "paragraph",
-        text: "Steps to setup Spotify API access:"
-      },
-      {
-        type: "orderedList",
-        items: [
+    description: [],
+    fields: [],
+    modeEnvVar: "SPOTIFY_AUTH_MODE",
+    modes: [
+      {
+        id: "official",
+        label: "Official Spotify API (needs Premium account)",
+        description: "Best metadata (album, ISRC, track number).",
+        details: [
           {
-            type: "link",
-            text: "Log in to the Spotify Developer Dashboard",
-            url: "https://developer.spotify.com/dashboard"
+            type: "note",
+            text: "You need a Premium Spotify Account to access the Spotify API."
           },
           {
-            type: "text",
-            text: 'Click "Create app"'
+            type: "paragraph",
+            text: "Steps to setup Spotify API access:"
           },
           {
-            type: "text",
-            text: "Copy the CLIENT_ID and CLIENT_SECRET from the app page"
+            type: "orderedList",
+            items: [
+              {
+                type: "link",
+                text: "Log in to the Spotify Developer Dashboard",
+                url: "https://developer.spotify.com/dashboard"
+              },
+              {
+                type: "text",
+                text: 'Click "Create app"'
+              },
+              {
+                type: "text",
+                text: "Copy the CLIENT_ID and CLIENT_SECRET from the app page"
+              }
+            ]
+          }
+        ],
+        fields: [
+          {
+            envVar: "SPOTIFY_CLIENT_ID",
+            label: "CLIENT_ID",
+            hint: "e.g. b94c59cdcd\u2026"
+          },
+          {
+            envVar: "SPOTIFY_CLIENT_SECRET",
+            label: "CLIENT_SECRET",
+            hint: "e.g. fa5a8a70ab\u2026"
           }
         ]
-      }
-    ],
-    fields: [
-      {
-        envVar: "SPOTIFY_CLIENT_ID",
-        label: "CLIENT_ID",
-        hint: "e.g. b94c59cdcd\u2026"
       },
       {
-        envVar: "SPOTIFY_CLIENT_SECRET",
-        label: "CLIENT_SECRET",
-        hint: "e.g. fa5a8a70ab\u2026"
+        id: "scrape",
+        label: "Scrape Spotify Web page (reads public page)",
+        description: "Limited metadata (no album, no ISRC).\nMay break if Spotify changes embed page.",
+        fields: []
       }
     ]
   };
   static cellComponent = SpotifyCell;
-  static client;
+  static client = null;
+  static authMode = null;
   constructor(task, logger) {
     super("SpotifyService", task, logger);
   }
-  async getClient() {
+  async resolveAuth() {
     return this.runExclusive("init", async () => {
-      if (!_SpotifyService.client) {
-        const vars = await this.env.getVariablesWithWizard(_SpotifyService.setupWizard);
-        _SpotifyService.client = SpotifyApi.withClientCredentials(vars["SPOTIFY_CLIENT_ID"], vars["SPOTIFY_CLIENT_SECRET"]);
+      if (_SpotifyService.authMode !== null) return;
+      await this.env.getVariablesWithWizard(_SpotifyService.setupWizard);
+      const mode = process.env.SPOTIFY_AUTH_MODE ?? "official";
+      _SpotifyService.authMode = mode;
+      if (mode === "official") {
+        _SpotifyService.client = SpotifyApi.withClientCredentials(process.env.SPOTIFY_CLIENT_ID, process.env.SPOTIFY_CLIENT_SECRET);
       }
-      return _SpotifyService.client;
     });
   }
+  async getClient() {
+    await this.resolveAuth();
+    if (!_SpotifyService.client) {
+      throw new Error("Spotify client not initialized (scrape mode active)");
+    }
+    return _SpotifyService.client;
+  }
   /**
    * Fetches track details from the Spotify API.
    *
@@ -2461,27 +2679,76 @@ var SpotifyService = class _SpotifyService extends MetadataService {
     };
     return null;
   }
+  async fetchViaUrlInfo(url, trackId, isFallback) {
+    this.logger.info(`Fetching Spotify track via spotify-url-info: "${trackId}"\u2026`);
+    this.status.set({
+      type: StatusType.Processing,
+      message: "Get spotify track info (embed)",
+      timeTracking: true,
+      progress: 0
+    });
+    try {
+      const details = await getSpotifyEmbedDetails(url);
+      this.status.clear();
+      return convertSpotifyUrlInfoToTrack(url, details, {
+        isFallback
+      });
+    } catch (error) {
+      this.logger.error(`Error fetching Spotify track via spotify-url-info for ID ${trackId}:`, {
+        error
+      });
+      this.status.set({
+        type: StatusType.Error,
+        message: "Error fetching Spotify track info (embed)"
+      });
+      throw error;
+    }
+  }
   async getTrackMetadata(url) {
+    await this.resolveAuth();
     const trackId = _SpotifyService.parseUrl(url)?.id;
     if (!trackId) {
       throw new Error(`Invalid Spotify track URL: ${url}`);
     }
-    const spotifyTrack = await this.getTrackInfo(trackId);
-    if (!spotifyTrack) {
-      throw new Error(`Could not fetch Spotify track: ${trackId}`);
+    const mode = _SpotifyService.authMode ?? "official";
+    if (mode === "scrape") {
+      return this.fetchViaUrlInfo(url, trackId, false);
+    }
+    try {
+      const spotifyTrack = await this.getTrackInfo(trackId);
+      if (!spotifyTrack) {
+        throw new Error(`Could not fetch Spotify track: ${trackId}`);
+      }
+      const standardTrack = this.convertSpotifyTrack(spotifyTrack, url);
+      const metadata = {
+        ...standardTrack,
+        platform: "spotify",
+        apiProvider: "spotify",
+        uri: `SPOTIFY::TRACK::${spotifyTrack.id}`,
+        fetchedAt: /* @__PURE__ */ new Date(),
+        type: "track"
+      };
+      return metadata;
+    } catch (error) {
+      const fallbackEnabled = getMetadataProviderSettings("spotify").fallbackToWeb !== false;
+      if (!fallbackEnabled) {
+        this.logger.error(`Official Spotify API failed for "${trackId}" and Spotify Web fallback is disabled`, {
+          error
+        });
+        throw error;
+      }
+      this.logger.warn(`Official Spotify API failed for "${trackId}", falling back to spotify-url-info`, {
+        error
+      });
+      return this.fetchViaUrlInfo(url, trackId, true);
     }
-    const standardTrack = this.convertSpotifyTrack(spotifyTrack, url);
-    const metadata = {
-      ...standardTrack,
-      platform: "spotify",
-      apiProvider: "spotify",
-      uri: `SPOTIFY::TRACK::${spotifyTrack.id}`,
-      fetchedAt: /* @__PURE__ */ new Date(),
-      type: "track"
-    };
-    return metadata;
   }
   async searchTrack(sourceTrackMetadata) {
+    await this.resolveAuth();
+    const mode = _SpotifyService.authMode ?? "official";
+    if (mode === "scrape") {
+      throw new Error("Spotify search is not available in scrape mode. Switch to official API mode for search support.");
+    }
     const client = await this.getClient();
     const artist = sourceTrackMetadata.artists?.[0]?.name;
     const trackName = sourceTrackMetadata.trackName;
@@ -2952,15 +3219,15 @@ var DiscoveryMetadataService = class extends ServiceBase {
 };
 
 // src/flows/musicDownloadFlow/services/apis/songlink-client.ts
-import path2 from "path";
+import path3 from "path";
 
 // src/flows/musicDownloadFlow/services/metadata-providers/songlink/json.ts
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 async function ensureCacheDir() {
   try {
-    await fs3.access(getCacheDir());
+    await fs4.access(getCacheDir());
   } catch {
-    await fs3.mkdir(getCacheDir(), {
+    await fs4.mkdir(getCacheDir(), {
       recursive: true
     });
   }
@@ -2969,7 +3236,7 @@ __name(ensureCacheDir, "ensureCacheDir");
 async function loadJsonFile(filePath, defaultValue) {
   await ensureCacheDir();
   try {
-    const content = await fs3.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return defaultValue;
@@ -2977,7 +3244,7 @@ async function loadJsonFile(filePath, defaultValue) {
 }
 __name(loadJsonFile, "loadJsonFile");
 async function saveJsonFile(filePath, data) {
-  await fs3.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  await fs4.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
 }
 __name(saveJsonFile, "saveJsonFile");
 
@@ -2989,7 +3256,7 @@ __name(sleep, "sleep");
 
 // src/flows/musicDownloadFlow/services/apis/songlink-client.ts
 var SONGLINK_API_BASE_URL = "https://api.song.link/v1-alpha.1/links";
-var SONGLINK_RATE_PATH = path2.join(getCacheDir(), "songlink_rate.json");
+var SONGLINK_RATE_PATH = path3.join(getCacheDir(), "songlink_rate.json");
 var SONGLINK_HOURLY_LIMIT = 19;
 var HOUR_MS = 36e5;
 var SONGLINK_MAX_ATTEMPTS = 6;
@@ -3124,14 +3391,14 @@ var SUPPORTED_PLATFORMS = /* @__PURE__ */ new Set([
   "appleMusic",
   "itunes"
 ]);
-function parseArtistNames(artistName) {
+function parseArtistNames2(artistName) {
   if (!artistName) return [];
   return artistName.split(/,|&|\bfeat\.?\b|\bft\.?\b/i).map((n) => n.trim()).filter((n) => n.length > 0);
 }
-__name(parseArtistNames, "parseArtistNames");
+__name(parseArtistNames2, "parseArtistNames");
 function convertSonglinkEntityToTrackMetadata(platformKey, platformLink, entity) {
   if (!SUPPORTED_PLATFORMS.has(platformKey)) return null;
-  const artistNames = parseArtistNames(entity.artistName);
+  const artistNames = parseArtistNames2(entity.artistName);
   const platform = platformKey;
   const apiProvider = entity.apiProvider;
   const uriPrefix = platformKey === "youtubeMusic" ? "youtube" : platformKey;
@@ -3280,10 +3547,10 @@ var MusicBrainzClient = class _MusicBrainzClient {
    * Prefers the ISRC (an exact, cross-platform identifier) and falls back to a title + artist search.
    */
   async findRecordingId(params) {
-    const api = this.getApi();
+    const api2 = this.getApi();
     const { isrc, trackName, artistName } = params;
     if (isrc) {
-      const byIsrc = await api.search("recording", {
+      const byIsrc = await api2.search("recording", {
         query: {
           isrc
         }
@@ -3296,7 +3563,7 @@ var MusicBrainzClient = class _MusicBrainzClient {
         recording: trackName
       };
       if (artistName) query.artist = artistName;
-      const byName = await api.search("recording", {
+      const byName = await api2.search("recording", {
         query
       });
       const top = byName.recordings?.[0];
@@ -3549,9 +3816,9 @@ var DownloadService = class extends ServiceBase {
 };
 
 // src/utils/ffmpeg-setup.ts
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import { createWriteStream } from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 import * as https from "https";
 import AdmZip from "adm-zip";
 async function ensureFfmpeg(autoDownloadBinary = true) {
@@ -3576,21 +3843,21 @@ async function ensureFfmpeg(autoDownloadBinary = true) {
     }
     const versionDate = new Date(release.published_at).toISOString().split("T")[0];
     const binaryName = `ffmpeg_${versionDate}.exe`;
-    const binaryPath = path3.join(getBinDir(), binaryName);
+    const binaryPath = path4.join(getBinDir(), binaryName);
     try {
-      await fs4.access(binaryPath);
+      await fs5.access(binaryPath);
       globalLogger.info(`ffmpeg ${versionDate} already installed at ${binaryPath}`);
       return binaryPath;
     } catch {
       globalLogger.info(`ffmpeg ${versionDate} not found, downloading\u2026`);
     }
-    await fs4.mkdir(getBinDir(), {
+    await fs5.mkdir(getBinDir(), {
       recursive: true
     });
     await cleanupOldVersions("ffmpeg_", binaryName);
     const zipName = "ffmpeg-master-latest-win64-gpl.zip";
     const downloadUrl = `https://github.com/BtbN/FFmpeg-Builds/releases/download/${release.tag_name}/${zipName}`;
-    const zipPath = path3.join(getBinDir(), zipName);
+    const zipPath = path4.join(getBinDir(), zipName);
     await downloadFile(downloadUrl, zipPath);
     globalLogger.debug("Extracting ffmpeg.exe\u2026");
     const zip = new AdmZip(zipPath);
@@ -3600,9 +3867,9 @@ async function ensureFfmpeg(autoDownloadBinary = true) {
       throw new Error("ffmpeg.exe not found in the downloaded archive");
     }
     zip.extractEntryTo(ffmpegEntry, getBinDir(), false, true);
-    const extractedPath = path3.join(getBinDir(), "ffmpeg.exe");
-    await fs4.rename(extractedPath, binaryPath);
-    await fs4.unlink(zipPath);
+    const extractedPath = path4.join(getBinDir(), "ffmpeg.exe");
+    await fs5.rename(extractedPath, binaryPath);
+    await fs5.unlink(zipPath);
     globalLogger.info(`Successfully downloaded ffmpeg ${versionDate} to ${binaryPath}`);
     return binaryPath;
   } catch {
@@ -3617,14 +3884,14 @@ async function ensureFfmpeg(autoDownloadBinary = true) {
 __name(ensureFfmpeg, "ensureFfmpeg");
 async function findExistingBinary(prefix, suffix) {
   try {
-    const files = await fs4.readdir(getBinDir());
+    const files = await fs5.readdir(getBinDir());
     const binaries = files.filter((file) => file.startsWith(prefix) && file.endsWith(suffix));
     if (binaries.length === 0) {
       return null;
     }
     binaries.sort().reverse();
-    const binaryPath = path3.join(getBinDir(), binaries[0]);
-    await fs4.access(binaryPath);
+    const binaryPath = path4.join(getBinDir(), binaries[0]);
+    await fs5.access(binaryPath);
     return binaryPath;
   } catch (error) {
     globalLogger.warn(`Failed to find existing binary: ${error}`);
@@ -3659,10 +3926,10 @@ async function getLatestFfmpegRelease() {
 __name(getLatestFfmpegRelease, "getLatestFfmpegRelease");
 async function cleanupOldVersions(prefix, currentVersion) {
   try {
-    const files = await fs4.readdir(getBinDir());
+    const files = await fs5.readdir(getBinDir());
     const oldVersions = files.filter((file) => file.startsWith(prefix) && file.endsWith(".exe") && file !== currentVersion);
     for (const file of oldVersions) {
-      await fs4.unlink(path3.join(getBinDir(), file));
+      await fs5.unlink(path4.join(getBinDir(), file));
       globalLogger.info(`Cleaned up old version: ${file}`);
     }
   } catch (error) {
@@ -3690,7 +3957,7 @@ async function downloadFile(url, destination) {
         resolve();
       });
       fileStream.on("error", (error) => {
-        fs4.unlink(destination).catch(() => {
+        fs5.unlink(destination).catch(() => {
         });
         reject(error);
       });
@@ -3719,9 +3986,9 @@ async function readFileInfo(filePath, fallbackDurationMs) {
 __name(readFileInfo, "readFileInfo");
 
 // src/flows/musicDownloadFlow/services/download-providers/ytdlp/ytdlp-setup.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import { createWriteStream as createWriteStream2 } from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 import * as https2 from "https";
 async function ensureYtDlpSetup(autoDownloadBinary = true) {
   if (!autoDownloadBinary) {
@@ -3744,15 +4011,15 @@ async function ensureYtDlpSetup(autoDownloadBinary = true) {
       throw new Error("yt-dlp release not found");
     }
     const binaryName = `yt-dlp_${latestVersion}.exe`;
-    const binaryPath = path4.join(getBinDir(), binaryName);
+    const binaryPath = path5.join(getBinDir(), binaryName);
     try {
-      await fs5.access(binaryPath);
+      await fs6.access(binaryPath);
       globalLogger.info(`yt-dlp ${latestVersion} already installed at ${binaryPath}`);
       return binaryPath;
     } catch {
       globalLogger.info(`yt-dlp ${latestVersion} not found, downloading\u2026`);
     }
-    await fs5.mkdir(getBinDir(), {
+    await fs6.mkdir(getBinDir(), {
       recursive: true
     });
     await cleanupOldVersions2("yt-dlp_", binaryName);
@@ -3772,14 +4039,14 @@ async function ensureYtDlpSetup(autoDownloadBinary = true) {
 __name(ensureYtDlpSetup, "ensureYtDlpSetup");
 async function findExistingBinary2(prefix, suffix) {
   try {
-    const files = await fs5.readdir(getBinDir());
+    const files = await fs6.readdir(getBinDir());
     const binaries = files.filter((file) => file.startsWith(prefix) && file.endsWith(suffix));
     if (binaries.length === 0) {
       return null;
     }
     binaries.sort().reverse();
-    const binaryPath = path4.join(getBinDir(), binaries[0]);
-    await fs5.access(binaryPath);
+    const binaryPath = path5.join(getBinDir(), binaries[0]);
+    await fs6.access(binaryPath);
     return binaryPath;
   } catch (error) {
     globalLogger.warn(`Failed to find existing binary: ${error}`);
@@ -3814,10 +4081,10 @@ async function getLatestYtDlpVersion() {
 __name(getLatestYtDlpVersion, "getLatestYtDlpVersion");
 async function cleanupOldVersions2(prefix, currentVersion) {
   try {
-    const files = await fs5.readdir(getBinDir());
+    const files = await fs6.readdir(getBinDir());
     const oldVersions = files.filter((file) => file.startsWith(prefix) && file.endsWith(".exe") && file !== currentVersion);
     for (const file of oldVersions) {
-      await fs5.unlink(path4.join(getBinDir(), file));
+      await fs6.unlink(path5.join(getBinDir(), file));
       globalLogger.info(`Cleaned up old version: ${file}`);
     }
   } catch (error) {
@@ -3845,7 +4112,7 @@ async function downloadFile2(url, destination) {
         resolve();
       });
       fileStream.on("error", (error) => {
-        fs5.unlink(destination).catch(() => {
+        fs6.unlink(destination).catch(() => {
         });
         reject(error);
       });
@@ -3858,12 +4125,12 @@ __name(downloadFile2, "downloadFile");
 
 // src/flows/musicDownloadFlow/services/download-providers/ytdlp/YtDlpCell.tsx
 import React15 from "react";
-import path5 from "path";
+import path6 from "path";
 import { Text as Text11 } from "ink";
 var YtDlpCell = /* @__PURE__ */ __name(({ task, isSelected }) => {
   const downloadSource = task.attributes?.downloadSources.find((d) => d.provider === "ytdlp");
   const saved = downloadSource?.savedFile;
-  const display = saved ? path5.basename(saved.path) : downloadSource?.localFile?.name ?? downloadSource?.state ?? "";
+  const display = saved ? path6.basename(saved.path) : downloadSource?.localFile?.name ?? downloadSource?.state ?? "";
   const color = saved ? "cyan" : downloadSource?.state === "downloaded" ? "green" : "white";
   return /* @__PURE__ */ React15.createElement(Text11, {
     color,
@@ -3872,91 +4139,6 @@ var YtDlpCell = /* @__PURE__ */ __name(({ task, isSelected }) => {
   }, display);
 }, "YtDlpCell");
 
-// src/flows/musicDownloadFlow/saveSettings.ts
-import fs6 from "fs";
-
-// src/flows/musicDownloadFlow/settings.ts
-import * as os from "os";
-import * as path6 from "path";
-function extractProviderDefaults(registry) {
-  const result = {};
-  for (const key of registry.getFactories().keys()) {
-    const schema = registry.getConstructor(key)?.defaultSettings;
-    result[key] = schema ? Object.fromEntries(Object.entries(schema).map(([k, v]) => [
-      k,
-      v.defaultValue
-    ])) : {
-      enabled: true
-    };
-  }
-  return result;
-}
-__name(extractProviderDefaults, "extractProviderDefaults");
-function getPlatformDefaultMusicOutputDir() {
-  switch (process.platform) {
-    case "win32":
-      return path6.join(os.homedir(), "Music", "GoblinMalin");
-    case "darwin":
-      return path6.join(os.homedir(), "Music", "GoblinMalin");
-    default:
-      return path6.join(process.env.XDG_MUSIC_DIR ?? path6.join(os.homedir(), "Music"), "GoblinMalin");
-  }
-}
-__name(getPlatformDefaultMusicOutputDir, "getPlatformDefaultMusicOutputDir");
-var MEDIA_OUTPUT_DIR = getPlatformDefaultMusicOutputDir();
-var BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS = {
-  metadata: {
-    autoChooseBestSource: false,
-    providers: {},
-    discoveryProviders: {}
-  },
-  download: {
-    autoChooseBestSource: false,
-    autoSaveToOutputDir: true,
-    autoDeleteTempAfter24h: false,
-    autoRelocateMissingFiles: false,
-    outputDir: MEDIA_OUTPUT_DIR,
-    outputTemporaryDir: path6.join(MEDIA_OUTPUT_DIR, "tmp"),
-    providers: {}
-  },
-  ui: {
-    columnRatios: {}
-  }
-};
-
-// src/flows/musicDownloadFlow/saveSettings.ts
-function getFlowSettings() {
-  return SettingsStore.getInstance().getFlowSettings("music-downloader", BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS);
-}
-__name(getFlowSettings, "getFlowSettings");
-function getTempDownloadDir() {
-  return getFlowSettings().download.outputTemporaryDir;
-}
-__name(getTempDownloadDir, "getTempDownloadDir");
-function getDownloadProviderSettings(providerKey) {
-  return getFlowSettings().download.providers[providerKey] ?? {};
-}
-__name(getDownloadProviderSettings, "getDownloadProviderSettings");
-function clearTempDownloads() {
-  const dir = getTempDownloadDir();
-  if (fs6.existsSync(dir)) {
-    fs6.rmSync(dir, {
-      recursive: true,
-      force: true
-    });
-  }
-  globalLogger.info("Temporary downloads cleared");
-}
-__name(clearTempDownloads, "clearTempDownloads");
-function getSaveSettings() {
-  const s = getFlowSettings();
-  return {
-    outputDir: s.download.outputDir,
-    includeMusicBrainzTags: false
-  };
-}
-__name(getSaveSettings, "getSaveSettings");
-
 // src/flows/musicDownloadFlow/utils/tempFile.ts
 import { randomUUID } from "crypto";
 import * as fs7 from "fs";
@@ -5027,7 +5209,7 @@ var DownloadTask = class extends Task {
       }
       if (existingSavedPath) {
         if (existingSavedPath !== outputPath) {
-          const { moveFile } = await import("./metadata-K3LLTE6Z.js");
+          const { moveFile } = await import("./metadata-4273SL44.js");
           await moveFile(existingSavedPath, outputPath);
         }
         outputCreated = true;
@@ -9088,8 +9270,40 @@ var useActiveWizardPrompt = /* @__PURE__ */ __name((tasks) => {
 }, "useActiveWizardPrompt");
 
 // src/components/SetupWizardModal/SetupWizardModal.tsx
-function buildInteractiveItems(config) {
+function buildInteractiveItems(config, selectedMode) {
   const items = [];
+  if (config.modes) {
+    for (const mode of config.modes) {
+      items.push({
+        kind: "mode",
+        id: mode.id,
+        label: mode.label
+      });
+    }
+    const activeMode = config.modes.find((m) => m.id === selectedMode) ?? config.modes[0];
+    for (const block of activeMode.details ?? []) {
+      if (block.type === "orderedList") {
+        for (const item of block.items) {
+          if (item.type === "link") {
+            items.push({
+              kind: "link",
+              text: item.text,
+              url: item.url
+            });
+          }
+        }
+      }
+    }
+    for (const field of activeMode.fields) {
+      items.push({
+        kind: "field",
+        envVar: field.envVar,
+        label: field.label,
+        hint: field.hint
+      });
+    }
+    return items;
+  }
   for (const block of config.description) {
     if (block.type === "orderedList") {
       for (const item of block.items) {
@@ -9132,26 +9346,41 @@ var SetupWizardModal = /* @__PURE__ */ __name(({ tasks, terminalHeight, terminal
   const [focusedIndex, setFocusedIndex] = useState15(0);
   const [fieldValues, setFieldValues] = useState15({});
   const [editingField, setEditingField] = useState15(null);
+  const [selectedMode, setSelectedMode] = useState15(() => {
+    if (config?.modes && config.modeEnvVar) {
+      return process.env[config.modeEnvVar] ?? config.modes[0].id;
+    }
+    return "";
+  });
   const [prevConfig, setPrevConfig] = useState15(config);
   if (prevConfig !== config) {
     setPrevConfig(config);
     if (config) {
       setFocusedIndex(0);
       setEditingField(null);
-      setFieldValues(Object.fromEntries(config.fields.map((f) => [
+      const initialMode = config.modes && config.modeEnvVar ? process.env[config.modeEnvVar] ?? config.modes[0].id : "";
+      setSelectedMode(initialMode);
+      const activeFields2 = config.modes ? (config.modes.find((m) => m.id === initialMode) ?? config.modes[0]).fields : config.fields;
+      setFieldValues(Object.fromEntries(activeFields2.map((f) => [
         f.envVar,
         process.env[f.envVar] ?? ""
       ])));
     }
   }
-  const interactiveItems = useMemo3(() => config ? buildInteractiveItems(config) : [], [
-    config
+  const interactiveItems = useMemo3(() => config ? buildInteractiveItems(config, selectedMode) : [], [
+    config,
+    selectedMode
   ]);
   const handleSubmit = useCallback3(async () => {
     if (!config) return;
+    const activeFields2 = config.modes ? (config.modes.find((m) => m.id === selectedMode) ?? config.modes[0]).fields : config.fields;
     const nonEmpty = {};
     const toRemove = [];
-    for (const field of config.fields) {
+    if (config.modes && config.modeEnvVar) {
+      process.env[config.modeEnvVar] = selectedMode;
+      nonEmpty[config.modeEnvVar] = selectedMode;
+    }
+    for (const field of activeFields2) {
       const value = fieldValues[field.envVar] ?? "";
       if (value.trim()) {
         process.env[field.envVar] = value;
@@ -9171,16 +9400,24 @@ var SetupWizardModal = /* @__PURE__ */ __name(({ tasks, terminalHeight, terminal
         await saveEnvVar(key, value);
       }
     }
+    const resolvedValues = {};
+    if (config.modes && config.modeEnvVar) {
+      resolvedValues[config.modeEnvVar] = selectedMode;
+    }
+    for (const field of activeFields2) {
+      resolvedValues[field.envVar] = fieldValues[field.envVar] ?? "";
+    }
     if (wizardTask && wizardPrompt) {
       const current = wizardPrompt.getCurrentPrompt();
       if (current?.type === PromptType.SetupWizard) {
-        wizardPrompt.resolvePrompt(fieldValues);
+        wizardPrompt.resolvePrompt(resolvedValues);
       }
     }
     switchBack();
   }, [
     config,
     fieldValues,
+    selectedMode,
     wizardTask,
     wizardPrompt,
     switchBack
@@ -9280,6 +9517,20 @@ var SetupWizardModal = /* @__PURE__ */ __name(({ tasks, terminalHeight, terminal
           if (!item) return;
           if (item.kind === "link") openUrl(item.url);
           else if (item.kind === "field") setEditingField(item.envVar);
+          else if (item.kind === "mode") {
+            const newMode = item.id;
+            setSelectedMode(newMode);
+            if (config?.modes) {
+              const newActiveMode = config.modes.find((m) => m.id === newMode) ?? config.modes[0];
+              setFieldValues((prev) => ({
+                ...prev,
+                ...Object.fromEntries(newActiveMode.fields.map((f) => [
+                  f.envVar,
+                  process.env[f.envVar] ?? ""
+                ]))
+              }));
+            }
+          }
         }, "handler")
       }
     ]
@@ -9287,31 +9538,13 @@ var SetupWizardModal = /* @__PURE__ */ __name(({ tasks, terminalHeight, terminal
   if (!isActive || !config) return null;
   const borderColor = config.providerKey ? providerDisplayRegistry.get(config.providerKey).color : theme.ui.modalBorder;
   const modalWidth = Math.min(80, Math.max(60, terminalWidth - 6));
-  const labelWidth = Math.max(...config.fields.map((f) => f.label.length)) + 2;
-  let linkInteractiveIndex = 0;
-  return /* @__PURE__ */ React29.createElement(Box15, {
-    position: "absolute",
-    width: "100%",
-    height: terminalHeight,
-    flexDirection: "column",
-    justifyContent: "center",
-    alignItems: "center"
-  }, /* @__PURE__ */ React29.createElement(Box15, {
-    flexDirection: "column",
-    borderStyle: "round",
-    borderColor,
-    borderBackgroundColor: theme.ui.background,
-    paddingX: 2,
-    paddingY: 1,
-    width: modalWidth,
-    backgroundColor: theme.ui.background
-  }, /* @__PURE__ */ React29.createElement(Text25, {
-    bold: true,
-    color: borderColor
-  }, config.title), /* @__PURE__ */ React29.createElement(Box15, {
-    flexDirection: "column",
-    marginTop: 1
-  }, config.description.map((block, bi) => {
+  const activeMode = config.modes ? config.modes.find((m) => m.id === selectedMode) ?? config.modes[0] : void 0;
+  const activeFields = activeMode ? activeMode.fields : config.fields;
+  const labelWidth = activeFields.length > 0 ? Math.max(...activeFields.map((f) => f.label.length)) + 2 : 2;
+  const activeModeDescription = activeMode?.description;
+  const activeModeDetails = activeMode?.details;
+  let linkInteractiveIndex = config.modes ? config.modes.length : 0;
+  const renderContentBlocks = /* @__PURE__ */ __name((blocks) => blocks.map((block, bi) => {
     if (block.type === "note") {
       return /* @__PURE__ */ React29.createElement(Box15, {
         key: bi,
@@ -9361,17 +9594,74 @@ var SetupWizardModal = /* @__PURE__ */ __name(({ tasks, terminalHeight, terminal
       }));
     }
     return null;
-  })), /* @__PURE__ */ React29.createElement(Box15, {
+  }), "renderContentBlocks");
+  return /* @__PURE__ */ React29.createElement(Box15, {
+    position: "absolute",
+    width: "100%",
+    height: terminalHeight,
+    flexDirection: "column",
+    justifyContent: "center",
+    alignItems: "center"
+  }, /* @__PURE__ */ React29.createElement(Box15, {
+    flexDirection: "column",
+    borderStyle: "round",
+    borderColor,
+    borderBackgroundColor: theme.ui.background,
+    paddingX: 2,
+    paddingY: 1,
+    width: modalWidth,
+    backgroundColor: theme.ui.background
+  }, /* @__PURE__ */ React29.createElement(Text25, {
+    bold: true,
+    color: borderColor
+  }, config.title), config.modes && /* @__PURE__ */ React29.createElement(Box15, {
+    flexDirection: "column",
+    marginTop: 1
+  }, /* @__PURE__ */ React29.createElement(Text25, {
+    color: theme.text.heading,
+    bold: true
+  }, "Choose how to fetch Spotify metadata:"), config.modes.map((mode) => {
+    const itemIndex = interactiveItems.findIndex((it) => it.kind === "mode" && it.id === mode.id);
+    const isFocused = focusedIndex === itemIndex;
+    const isSelected = selectedMode === mode.id;
+    const itemColor = isFocused ? theme.action.primary : isSelected ? borderColor : theme.text.secondary;
+    return /* @__PURE__ */ React29.createElement(Box15, {
+      key: mode.id,
+      flexDirection: "row"
+    }, /* @__PURE__ */ React29.createElement(Text25, {
+      color: isFocused ? theme.action.primary : theme.text.muted
+    }, isFocused ? "\u261B " : "  "), /* @__PURE__ */ React29.createElement(Text25, {
+      color: itemColor,
+      bold: isSelected
+    }, isSelected ? "\u25C9 " : "\u25CB "), /* @__PURE__ */ React29.createElement(Text25, {
+      color: itemColor,
+      bold: isSelected || isFocused
+    }, mode.label));
+  }), activeModeDescription && /* @__PURE__ */ React29.createElement(Box15, {
+    marginTop: 1,
+    paddingLeft: 4
+  }, /* @__PURE__ */ React29.createElement(Text25, {
+    color: theme.text.secondary,
+    italic: true
+  }, activeModeDescription)), activeModeDetails && activeModeDetails.length > 0 && /* @__PURE__ */ React29.createElement(Box15, {
+    flexDirection: "column",
+    marginTop: 1,
+    paddingLeft: 4
+  }, renderContentBlocks(activeModeDetails))), !config.modes && /* @__PURE__ */ React29.createElement(Box15, {
     flexDirection: "column",
     marginTop: 1
-  }, config.fields.map((field, fi) => {
+  }, renderContentBlocks(config.description)), /* @__PURE__ */ React29.createElement(Box15, {
+    flexDirection: "column",
+    marginTop: 1,
+    paddingLeft: config.modes ? 2 : 0
+  }, activeFields.map((field, fi) => {
     const itemIndex = interactiveItems.findIndex((it) => it.kind === "field" && it.envVar === field.envVar);
     const isFocused = focusedIndex === itemIndex;
     const isEditing = editingField === field.envVar;
     return /* @__PURE__ */ React29.createElement(Box15, {
       flexDirection: "row",
       key: field.envVar,
-      marginTop: fi === 0 ? 1 : 0,
+      marginTop: fi === 0 ? config.modes ? 0 : 1 : 0,
       height: 3,
       alignItems: "center"
     }, /* @__PURE__ */ React29.createElement(Text25, {
@@ -9615,10 +9905,10 @@ import { spawn as spawn3, exec as exec2 } from "child_process";
 import open2 from "open";
 
 // src/updater/installSource.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join10 } from "path";
-var _require = createRequire(import.meta.url);
+var _require = createRequire2(import.meta.url);
 var IS_SEA = (() => {
   try {
     const sea = _require("node:sea");

package/dist/{chunk-4NSWYXSP.js → chunk-QSUGRYOC.js}

@@ -109,7 +109,7 @@ dotenv.config({
 });
 function resolveAppVersion() {
   try {
-    return "0.1.13";
+    return "0.1.14";
   } catch {
     const _req = createRequire(import.meta.url);
     return _req("../package.json").version;
@@ -121,9 +121,9 @@ var APP_VERSION = resolveAppVersion();
 // src/settings/appSettings.ts
 var DEFAULT_APP_SETTINGS = {
   general: {
-    reopenLastSession: false,
+    reopenLastSession: true,
     appDataDir: DEFAULT_APP_DATA_DIR,
-    animationsEnabled: false,
+    animationsEnabled: true,
     theme: "dark",
     showWelcomeTutorial: true,
     checkForUpdates: true

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   start
-} from "./chunk-OUQ2CB5Q.js";
-import "./chunk-4NSWYXSP.js";
+} from "./chunk-5KBWKKXR.js";
+import "./chunk-QSUGRYOC.js";
 
 // src/cli.ts
 start();

package/dist/index.js

@@ -2,8 +2,8 @@ import {
   src_default,
   start,
   withFullScreen
-} from "./chunk-OUQ2CB5Q.js";
-import "./chunk-4NSWYXSP.js";
+} from "./chunk-5KBWKKXR.js";
+import "./chunk-QSUGRYOC.js";
 export {
   src_default as default,
   start,

package/dist/{metadata-K3LLTE6Z.js → metadata-4273SL44.js}

@@ -1,7 +1,7 @@
 import {
   cleanAndTagFlac,
   moveFile
-} from "./chunk-4NSWYXSP.js";
+} from "./chunk-QSUGRYOC.js";
 export {
   cleanAndTagFlac,
   moveFile

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "goblin-malin",
-    "version": "0.1.13",
+    "version": "0.1.14",
     "description": "A keyboard-driven terminal UI for downloading and tagging music tracks with metadata from Spotify and YouTube",
     "type": "module",
     "main": "./dist/index.js",
@@ -103,7 +103,6 @@
         "eslint-plugin-react-hooks": "^7.1.1",
         "postject": "^1.0.0-alpha.6",
         "prettier": "^3.8.3",
-        "spotify-url-info": "^3.3.0",
         "ts-node": "^10.9.2",
         "tsup": "^8.0.0",
         "tsx": "^4.21.0",
@@ -134,6 +133,7 @@
         "open": "^11.0.0",
         "react": "^19.2.6",
         "slsk-client": "^1.1.0",
+        "spotify-url-info": "^3.3.0",
         "winston": "^3.19.0",
         "winston-transport": "^4.9.0",
         "ytdlp-nodejs": "^3.4.4",