goblin-malin 0.1.0 → 0.1.1

package/README.md

@@ -8,23 +8,35 @@ A keyboard-driven terminal UI for downloading and tagging music tracks with meta
 
 ## Installation
 
-No easy installation yet. You can only run the project as developer:
+### Running the project as a developer
+
+You can run the project as a developer:
 
 1. Clone the repository and open a terminal in the project directory
 2. Install [Node.js](https://nodejs.org/en/download) and [yarn](https://classic.yarnpkg.com/lang/en/docs/install)
 3. Install dependencies in the project directory: `yarn install`
 4. Run the application: `yarn run dev`
 
+### Launching the app in js code
+
+> Not customizable yet
+
+```js
+import GoblinMalin from "goblin-malin";
+
+GoblinMalin.start();
+```
+
 ## Steps
 
 - Import track URLs from compatible streaming platforms with `Ctrl+V`:
-  - Spotify
-  - YouTube
+  - `Spotify`
+  - `YouTube`
 - System fetches primary metadata from the corresponding URL platform
 - System discovers the same track on other platforms (cross-referencing via ISRC or track/artist name)
 - Filters/orders metadata sources by relevance or leaves the default ranking chosen by the system (use `TAB` key to switch the focused window).
 - System downloads matching tracks from available download providers:
-  - yt-dlp
+  - `yt-dlp`
 - User selects the best download source and previews the audio
 - User saves the file to the desired folder with embedded tags
 

package/dist/{chunk-DJTET7PY.js → chunk-IVBZEO3V.js}

@@ -521,7 +521,7 @@ var FlowSettings = class {
 };
 
 // src/flows/musicDownloadFlow/utils/downloadTask.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 
 // src/base/task/task-status.ts
 var StatusType = /* @__PURE__ */ (function(StatusType2) {
@@ -995,6 +995,9 @@ function computeOutputPath(compiled, outputDir) {
 }
 __name(computeOutputPath, "computeOutputPath");
 
+// src/flows/musicDownloadFlow/saveSettings.ts
+import fs2 from "fs";
+
 // src/flows/musicDownloadFlow/settings.ts
 import * as os from "os";
 import * as path2 from "path";
@@ -1012,6 +1015,7 @@ function extractProviderDefaults(registry) {
   return result;
 }
 __name(extractProviderDefaults, "extractProviderDefaults");
+var MEDIA_OUTPUT_DIR = path2.join(os.homedir(), "Music", "GoblinMalin");
 var BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS = {
   metadata: {
     autoFetchOnImport: false,
@@ -1023,7 +1027,8 @@ var BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS = {
     autoSaveToOutputDir: true,
     autoDeleteTempAfter24h: false,
     autoRelocateMissingFiles: false,
-    outputDir: path2.join(os.homedir(), "Music"),
+    outputDir: MEDIA_OUTPUT_DIR,
+    outputTemporaryDir: path2.join(MEDIA_OUTPUT_DIR, "tmp"),
     providers: {}
   }
 };
@@ -1033,10 +1038,20 @@ function getFlowSettings() {
   return SettingsStore.getInstance().getFlowSettings("music-downloader", BASE_DEFAULT_MUSIC_DOWNLOAD_FLOW_SETTINGS);
 }
 __name(getFlowSettings, "getFlowSettings");
-function getDownloadDir() {
-  return getFlowSettings().download.outputDir;
+function getTempDownloadDir() {
+  return getFlowSettings().download.outputTemporaryDir;
 }
-__name(getDownloadDir, "getDownloadDir");
+__name(getTempDownloadDir, "getTempDownloadDir");
+function clearTempDownloads() {
+  const dir = getTempDownloadDir();
+  if (fs2.existsSync(dir)) {
+    fs2.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+  }
+}
+__name(clearTempDownloads, "clearTempDownloads");
 function getSaveSettings() {
   const s = getFlowSettings();
   return {
@@ -1280,7 +1295,7 @@ var DownloadTask = class extends Task {
       for (const src of sources) {
         if (src !== selectedSource && src.savedFile) {
           try {
-            await fs2.unlink(src.savedFile.path);
+            await fs3.unlink(src.savedFile.path);
           } catch (e) {
             if (e.code !== "ENOENT") throw e;
           }
@@ -1293,7 +1308,7 @@ var DownloadTask = class extends Task {
         }
         outputCreated = true;
       } else {
-        await fs2.copyFile(selectedSource.localFile.path, outputPath);
+        await fs3.copyFile(selectedSource.localFile.path, outputPath);
         outputCreated = true;
       }
       await cleanAndTagFlac(outputPath, tags);
@@ -1315,7 +1330,7 @@ var DownloadTask = class extends Task {
       });
     } catch (err) {
       if (outputCreated) {
-        await fs2.unlink(outputPath).catch(() => {
+        await fs3.unlink(outputPath).catch(() => {
         });
       }
       this.status.set({
@@ -1377,7 +1392,7 @@ __name(taskIdFromUrl, "taskIdFromUrl");
 
 // src/utils/cache.ts
 import { create } from "flat-cache";
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 var CACHE_ID = "api-cache";
 var cacheDir = getCacheDir();
 var cache = create({
@@ -1393,7 +1408,7 @@ var cache = create({
 function clearCache() {
   cache.clear();
   try {
-    fs3.rmSync(cacheDir, {
+    fs4.rmSync(cacheDir, {
       recursive: true,
       force: true
     });
@@ -1766,7 +1781,7 @@ var EnvironmentError = class extends Error {
 };
 
 // src/base/env.ts
-import * as fs4 from "fs/promises";
+import * as fs5 from "fs/promises";
 import * as path3 from "path";
 var Env = class {
   static {
@@ -1806,7 +1821,7 @@ var Env = class {
   async saveToEnvFile(key, value) {
     const envPath = path3.resolve(process.cwd(), ".env");
     try {
-      const envContent = await fs4.readFile(envPath, {
+      const envContent = await fs5.readFile(envPath, {
         encoding: "utf-8",
         flag: "w+"
       });
@@ -1822,7 +1837,7 @@ var Env = class {
 ${newEntry}
 ` : `${newEntry}
 `;
-      await fs4.writeFile(envPath, updatedContent, "utf-8");
+      await fs5.writeFile(envPath, updatedContent, "utf-8");
       this.logger.info(`Successfully added ${key} to .env file.`);
     } catch (error) {
       this.logger.error(`Failed to save ${key} to .env file:`, {
@@ -2793,7 +2808,7 @@ _ts_decorate2([
 ], YoutubeService.prototype, "getTrackMetadata", null);
 
 // src/flows/musicDownloadFlow/services/download-providers/ytdlp/YtDlpService.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 import { YtDlp } from "ytdlp-nodejs";
 
@@ -2811,7 +2826,7 @@ var DownloadService = class extends ServiceBase {
 };
 
 // src/utils/ytdlp-setup.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import { createWriteStream } from "fs";
 import * as path4 from "path";
 import * as https from "https";
@@ -2830,13 +2845,13 @@ async function ensureYtDlpSetup() {
     const binaryName = `yt-dlp_${latestVersion}.exe`;
     const binaryPath = path4.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 cleanupOldVersions("yt-dlp_", binaryName);
@@ -2856,14 +2871,14 @@ async function ensureYtDlpSetup() {
 __name(ensureYtDlpSetup, "ensureYtDlpSetup");
 async function findExistingBinary(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);
+    await fs6.access(binaryPath);
     return binaryPath;
   } catch (error) {
     globalLogger.warn(`Failed to find existing binary: ${error}`);
@@ -2898,10 +2913,10 @@ async function getLatestYtDlpVersion() {
 __name(getLatestYtDlpVersion, "getLatestYtDlpVersion");
 async function cleanupOldVersions(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(path4.join(getBinDir(), file));
       globalLogger.info(`Cleaned up old version: ${file}`);
     }
   } catch (error) {
@@ -2929,7 +2944,7 @@ async function downloadFile(url, destination) {
         resolve2();
       });
       fileStream.on("error", (error) => {
-        fs5.unlink(destination).catch(() => {
+        fs6.unlink(destination).catch(() => {
         });
         reject(error);
       });
@@ -2941,7 +2956,7 @@ async function downloadFile(url, destination) {
 __name(downloadFile, "downloadFile");
 
 // src/utils/ffmpeg-setup.ts
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import { createWriteStream as createWriteStream2 } from "fs";
 import * as path5 from "path";
 import * as https2 from "https";
@@ -2962,13 +2977,13 @@ async function ensureFfmpeg() {
     const binaryName = `ffmpeg_${versionDate}.exe`;
     const binaryPath = path5.join(getBinDir(), binaryName);
     try {
-      await fs6.access(binaryPath);
+      await fs7.access(binaryPath);
       globalLogger.info(`ffmpeg ${versionDate} already installed at ${binaryPath}`);
       return binaryPath;
     } catch {
       globalLogger.info(`ffmpeg ${versionDate} not found, downloading\u2026`);
     }
-    await fs6.mkdir(getBinDir(), {
+    await fs7.mkdir(getBinDir(), {
       recursive: true
     });
     await cleanupOldVersions2("ffmpeg_", binaryName);
@@ -2985,8 +3000,8 @@ async function ensureFfmpeg() {
     }
     zip.extractEntryTo(ffmpegEntry, getBinDir(), false, true);
     const extractedPath = path5.join(getBinDir(), "ffmpeg.exe");
-    await fs6.rename(extractedPath, binaryPath);
-    await fs6.unlink(zipPath);
+    await fs7.rename(extractedPath, binaryPath);
+    await fs7.unlink(zipPath);
     globalLogger.info(`Successfully downloaded ffmpeg ${versionDate} to ${binaryPath}`);
     return binaryPath;
   } catch (error) {
@@ -3001,14 +3016,14 @@ async function ensureFfmpeg() {
 __name(ensureFfmpeg, "ensureFfmpeg");
 async function findExistingBinary2(prefix, suffix) {
   try {
-    const files = await fs6.readdir(getBinDir());
+    const files = await fs7.readdir(getBinDir());
     const binaries = files.filter((file) => file.startsWith(prefix) && file.endsWith(suffix));
     if (binaries.length === 0) {
       return null;
     }
     binaries.sort().reverse();
     const binaryPath = path5.join(getBinDir(), binaries[0]);
-    await fs6.access(binaryPath);
+    await fs7.access(binaryPath);
     return binaryPath;
   } catch (error) {
     globalLogger.warn(`Failed to find existing binary: ${error}`);
@@ -3043,10 +3058,10 @@ async function getLatestFfmpegRelease() {
 __name(getLatestFfmpegRelease, "getLatestFfmpegRelease");
 async function cleanupOldVersions2(prefix, currentVersion) {
   try {
-    const files = await fs6.readdir(getBinDir());
+    const files = await fs7.readdir(getBinDir());
     const oldVersions = files.filter((file) => file.startsWith(prefix) && file.endsWith(".exe") && file !== currentVersion);
     for (const file of oldVersions) {
-      await fs6.unlink(path5.join(getBinDir(), file));
+      await fs7.unlink(path5.join(getBinDir(), file));
       globalLogger.info(`Cleaned up old version: ${file}`);
     }
   } catch (error) {
@@ -3074,7 +3089,7 @@ async function downloadFile2(url, destination) {
         resolve2();
       });
       fileStream.on("error", (error) => {
-        fs6.unlink(destination).catch(() => {
+        fs7.unlink(destination).catch(() => {
         });
         reject(error);
       });
@@ -3180,11 +3195,12 @@ var YtDlpService = class _YtDlpService extends DownloadService {
       });
       const artistName = trackMetadata.artists?.[0]?.name || "Unknown Artist";
       const outputName = `${artistName} - ${trackMetadata.trackName}`;
+      const uriSlug = trackMetadata.uri?.replace(/::/g, "-").replace(/:/g, "-") ?? "";
       const format = "flac";
-      const filename = `${outputName}.${format}`;
-      const fullPath = path7.join(getDownloadDir(), filename);
+      const filename = uriSlug ? `${outputName} ${uriSlug}.${format}` : `${outputName}.${format}`;
+      const fullPath = path7.join(getTempDownloadDir(), filename);
       let localFile;
-      if (fs7.existsSync(fullPath)) {
+      if (fs8.existsSync(fullPath)) {
         this.logger.info(`File already exists, skipping download: ${filename}`);
         localFile = {
           state: "found",
@@ -3194,14 +3210,14 @@ var YtDlpService = class _YtDlpService extends DownloadService {
           sourceUrl: trackUrl
         };
       } else {
-        if (!fs7.existsSync(getDownloadDir())) {
-          fs7.mkdirSync(getDownloadDir(), {
+        if (!fs8.existsSync(getTempDownloadDir())) {
+          fs8.mkdirSync(getTempDownloadDir(), {
             recursive: true
           });
         }
         const cookiesPath = path7.join(getBinDir(), "cookies.txt");
         let downloadOptions = {
-          paths: getDownloadDir(),
+          paths: getTempDownloadDir(),
           output: filename,
           audioFormat: format,
           extractAudio: true,
@@ -3213,7 +3229,7 @@ var YtDlpService = class _YtDlpService extends DownloadService {
             this.logger.debug(`Download progress: ${progress.percentage}% ${progress.speed_str} (ETA: ${progress.eta_str})`);
           }, "onProgress")
         };
-        if (fs7.existsSync(cookiesPath)) {
+        if (fs8.existsSync(cookiesPath)) {
           this.logger.debug(`Using cookies from ${cookiesPath}`);
           downloadOptions.cookies = cookiesPath;
         } else {
@@ -3386,6 +3402,23 @@ function buildFlowSettingsItems(flowSettings, metadataProviders, downloadProvide
       }
     }), "set")
   });
+  items.push({
+    kind: "textInput",
+    indent: 0,
+    label: "\u{1F5C1}  Temporary download directory",
+    get: /* @__PURE__ */ __name(() => flowSettings.download.outputTemporaryDir, "get"),
+    set: /* @__PURE__ */ __name((v) => onChange({
+      download: {
+        outputTemporaryDir: v
+      }
+    }), "set")
+  });
+  items.push({
+    kind: "action",
+    indent: 0,
+    label: "\u26D2  Clear temporary downloads",
+    run: /* @__PURE__ */ __name(() => clearTempDownloads(), "run")
+  });
   if (downloadProviders.length > 0) {
     items.push({
       kind: "subHeader",
@@ -3831,10 +3864,10 @@ import { spawn as spawn2 } from "child_process";
 import * as net from "net";
 import * as path9 from "path";
 import * as os2 from "os";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 // src/utils/mpv-setup.ts
-import * as fs8 from "fs/promises";
+import * as fs9 from "fs/promises";
 import { createWriteStream as createWriteStream3 } from "fs";
 import * as path8 from "path";
 import * as https3 from "https";
@@ -3874,13 +3907,13 @@ async function ensureMpv() {
     const binaryName = `mpv_${version}.exe`;
     const binaryPath = path8.join(getBinDir(), binaryName);
     try {
-      await fs8.access(binaryPath);
+      await fs9.access(binaryPath);
       globalLogger.info(`mpv ${version} already at ${binaryPath}`);
       return binaryPath;
     } catch {
       globalLogger.info(`Downloading mpv ${version}...`);
     }
-    await fs8.mkdir(getBinDir(), {
+    await fs9.mkdir(getBinDir(), {
       recursive: true
     });
     await cleanupOldVersions3("mpv_", binaryName);
@@ -3892,8 +3925,8 @@ async function ensureMpv() {
     await downloadFile3(asset.browser_download_url, archivePath);
     globalLogger.info("Extracting mpv.exe...");
     await extract7z(archivePath, getBinDir(), "mpv.exe");
-    await fs8.rename(path8.join(getBinDir(), "mpv.exe"), binaryPath);
-    await fs8.unlink(archivePath);
+    await fs9.rename(path8.join(getBinDir(), "mpv.exe"), binaryPath);
+    await fs9.unlink(archivePath);
     globalLogger.info(`mpv ${version} installed at ${binaryPath}`);
     return binaryPath;
   } catch (err) {
@@ -3950,11 +3983,11 @@ async function extract7z(archivePath, destDir, fileFilter) {
 __name(extract7z, "extract7z");
 async function findExistingBinary3(prefix, suffix) {
   try {
-    const files = await fs8.readdir(getBinDir());
+    const files = await fs9.readdir(getBinDir());
     const matches = files.filter((f) => f.startsWith(prefix) && f.endsWith(suffix)).sort().reverse();
     if (!matches.length) return null;
     const p = path8.join(getBinDir(), matches[0]);
-    await fs8.access(p);
+    await fs9.access(p);
     return p;
   } catch {
     return null;
@@ -3963,10 +3996,10 @@ async function findExistingBinary3(prefix, suffix) {
 __name(findExistingBinary3, "findExistingBinary");
 async function cleanupOldVersions3(prefix, currentName) {
   try {
-    const files = await fs8.readdir(getBinDir());
+    const files = await fs9.readdir(getBinDir());
     for (const f of files) {
       if (f.startsWith(prefix) && f.endsWith(".exe") && f !== currentName) {
-        await fs8.unlink(path8.join(getBinDir(), f));
+        await fs9.unlink(path8.join(getBinDir(), f));
         globalLogger.info(`Removed old mpv binary: ${f}`);
       }
     }
@@ -3991,7 +4024,7 @@ async function downloadFile3(url, destination) {
       res.pipe(ws);
       ws.on("finish", () => ws.close(() => resolve2()));
       ws.on("error", (e) => {
-        fs8.unlink(destination).catch(() => {
+        fs9.unlink(destination).catch(() => {
         });
         reject(e);
       });
@@ -4048,8 +4081,8 @@ var MpvPlayer = class extends EventEmitter2 {
     return this._starting;
   }
   async _start() {
-    if (process.platform !== "win32" && fs9.existsSync(this.socketPath)) {
-      fs9.unlinkSync(this.socketPath);
+    if (process.platform !== "win32" && fs10.existsSync(this.socketPath)) {
+      fs10.unlinkSync(this.socketPath);
     }
     const mpvBin = await ensureMpv();
     this.mpvProcess = spawn2(mpvBin, [
@@ -4083,7 +4116,7 @@ var MpvPlayer = class extends EventEmitter2 {
     return new Promise((resolve2, reject) => {
       const deadline = Date.now() + timeoutMs;
       const poll = /* @__PURE__ */ __name(() => {
-        if (fs9.existsSync(this.socketPath)) {
+        if (fs10.existsSync(this.socketPath)) {
           resolve2();
         } else if (Date.now() >= deadline) {
           reject(new Error("Timed out waiting for mpv IPC socket"));
@@ -7493,7 +7526,7 @@ var MetadataPanel = /* @__PURE__ */ __name(({ selectedTask, width, height }) =>
 // src/components/SecondaryPanel/DownloadPanel/DownloadPanel.tsx
 import React45, { useState as useState15, useEffect as useEffect14 } from "react";
 import { Box as Box33, Text as Text42, useInput as useInput9 } from "ink";
-import fs11 from "fs";
+import fs12 from "fs";
 
 // src/components/SecondaryPanel/DownloadPanel/DownloadSourceTree/DownloadSourceTree.tsx
 import React39 from "react";
@@ -7819,7 +7852,7 @@ var DownloadSourceTree = /* @__PURE__ */ __name(({ sources, selectedSourceIndex,
 import React44, { useState as useState14, useEffect as useEffect13 } from "react";
 import { Box as Box32, Text as Text41, useInput as useInput8 } from "ink";
 import * as path11 from "path";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 
 // src/components/SecondaryPanel/DownloadPanel/PlaybackBar.tsx
 import React40 from "react";
@@ -8238,7 +8271,7 @@ var DownloadSourceDetail = /* @__PURE__ */ __name(({ source, savedSource, compil
   }
   const isSaved = !!source.savedFile;
   const borderColor = isSaved ? "white" : "green";
-  const outputFileExists = !isSaved && compiled !== null && fs10.existsSync(path11.join(outputDir, computeOutputFilename(compiled)));
+  const outputFileExists = !isSaved && compiled !== null && fs11.existsSync(path11.join(outputDir, computeOutputFilename(compiled)));
   const headerLabel = isSaved ? "FILE ON DISK" : "NEW FILE";
   const headerColor = isSaved ? "white" : "green";
   const innerW = width - 2;
@@ -8544,7 +8577,7 @@ var DownloadPanel = /* @__PURE__ */ __name(({ selectedTask, width, height }) =>
         hint: "Absolute path to the FLAC file"
       });
       if (!newPath.trim()) return;
-      if (!fs11.existsSync(newPath)) return;
+      if (!fs12.existsSync(newPath)) return;
       typedTask?.updateLocalFile(sourceIdx, newPath);
     } catch {
     }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   start
-} from "./chunk-DJTET7PY.js";
+} from "./chunk-IVBZEO3V.js";
 import "./chunk-ECLAXOR2.js";
 
 // src/cli.ts

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   src_default,
   start,
   withFullScreen
-} from "./chunk-DJTET7PY.js";
+} from "./chunk-IVBZEO3V.js";
 import "./chunk-ECLAXOR2.js";
 export {
   src_default as default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goblin-malin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A keyboard-driven terminal UI for downloading and tagging music tracks with metadata from Spotify and YouTube",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,8 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "docs/screenshots"
   ],
   "scripts": {
     "dev": "tsx src/cli.ts",