goblin-malin 0.1.0

package/dist/chunk-ECLAXOR2.js

@@ -0,0 +1,423 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/utils/metadata.ts
+import * as fs3 from "fs";
+import * as path5 from "path";
+import NodeId3 from "node-id3";
+import { readFlacTags, writeFlacTags } from "flac-tagger";
+
+// src/base/logger/logger.ts
+import fs2 from "fs";
+import path4 from "path";
+import chalk from "chalk";
+import winston from "winston";
+
+// src/base/logger/ink-transport.ts
+import Transport from "winston-transport";
+var InkTransport = class extends Transport {
+  static {
+    __name(this, "InkTransport");
+  }
+  history = [];
+  pending = [];
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super(opts);
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+    this.history.push(info);
+    this.pending.push(info);
+    this.notifySubscribers();
+    callback();
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    callback([
+      ...this.history
+    ]);
+    return () => {
+      this.subscribers.delete(callback);
+    };
+  }
+  notifySubscribers() {
+    const batch = [
+      ...this.pending
+    ];
+    this.pending = [];
+    this.subscribers.forEach((callback) => callback(batch));
+  }
+  getLogs() {
+    return [
+      ...this.history
+    ];
+  }
+  filterLogs(predicate) {
+    return this.history.filter(predicate);
+  }
+};
+var inkTransport = new InkTransport({
+  maxLogs: 300,
+  level: "debug"
+});
+
+// src/base/logger/types.ts
+var LogLevel = /* @__PURE__ */ (function(LogLevel2) {
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["DEBUG"] = "DEBUG";
+  return LogLevel2;
+})({});
+
+// src/utils/appPaths.ts
+import path3 from "path";
+
+// src/settings/settingsStore.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import { EventEmitter } from "events";
+
+// src/constants.ts
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+dotenv.config();
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PROJECT_ROOT = path.join(__dirname, "..");
+
+// src/settings/appSettings.ts
+var DEFAULT_APP_SETTINGS = {
+  general: {
+    reopenLastSession: false,
+    appDataDir: PROJECT_ROOT,
+    animationsEnabled: false
+  }
+};
+
+// src/utils/deepMerge.ts
+function deepMerge(target, source) {
+  if (typeof source !== "object" || source === null) return source;
+  if (typeof target !== "object" || target === null) return source;
+  const result = {
+    ...target
+  };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal !== void 0) {
+      if (typeof srcVal === "object" && srcVal !== null && !Array.isArray(srcVal) && typeof tgtVal === "object" && tgtVal !== null && !Array.isArray(tgtVal)) {
+        result[key] = deepMerge(tgtVal, srcVal);
+      } else {
+        result[key] = srcVal;
+      }
+    }
+  }
+  return result;
+}
+__name(deepMerge, "deepMerge");
+
+// src/settings/settingsStore.ts
+var CONFIG_DIR = path2.join(PROJECT_ROOT, "config");
+var SETTINGS_PATH = path2.join(CONFIG_DIR, "settings.json");
+var SettingsStore = class _SettingsStore {
+  static {
+    __name(this, "SettingsStore");
+  }
+  static instance;
+  cache = null;
+  emitter = new EventEmitter();
+  static getInstance() {
+    if (!_SettingsStore.instance) _SettingsStore.instance = new _SettingsStore();
+    return _SettingsStore.instance;
+  }
+  readFromDisk() {
+    try {
+      const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return {
+        general: DEFAULT_APP_SETTINGS.general,
+        flows: {}
+      };
+    }
+  }
+  writeToDisk(settings) {
+    fs.mkdirSync(CONFIG_DIR, {
+      recursive: true
+    });
+    const tmp = SETTINGS_PATH + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(settings, null, 2), "utf-8");
+    fs.renameSync(tmp, SETTINGS_PATH);
+    this.cache = settings;
+    this.emitter.emit("change");
+  }
+  getCached() {
+    if (!this.cache) this.cache = this.readFromDisk();
+    return this.cache;
+  }
+  // ── App (global) settings ──────────────────────────────────────────────────
+  getAppSettings() {
+    const s = this.getCached();
+    return deepMerge(DEFAULT_APP_SETTINGS, {
+      general: s.general
+    });
+  }
+  writeAppSettings(settings) {
+    const current = this.getCached();
+    this.writeToDisk({
+      ...current,
+      general: settings.general
+    });
+  }
+  // ── Flow settings ──────────────────────────────────────────────────────────
+  getFlowSettings(flowId, defaults) {
+    const stored = this.getCached().flows?.[flowId] ?? {};
+    return deepMerge(defaults, stored);
+  }
+  writeFlowSettings(flowId, settings) {
+    const current = this.getCached();
+    this.writeToDisk({
+      ...current,
+      flows: {
+        ...current.flows ?? {},
+        [flowId]: settings
+      }
+    });
+  }
+  // ── Change notifications ───────────────────────────────────────────────────
+  onSettingsChanged(callback) {
+    this.emitter.on("change", callback);
+    return () => {
+      this.emitter.off("change", callback);
+    };
+  }
+};
+
+// src/utils/appPaths.ts
+function dataDir() {
+  return SettingsStore.getInstance().getAppSettings().general.appDataDir;
+}
+__name(dataDir, "dataDir");
+function getCacheDir() {
+  return path3.join(dataDir(), "cache");
+}
+__name(getCacheDir, "getCacheDir");
+function getBinDir() {
+  return path3.join(dataDir(), "bin");
+}
+__name(getBinDir, "getBinDir");
+function getLogsPath() {
+  return path3.join(dataDir(), "app.log");
+}
+__name(getLogsPath, "getLogsPath");
+
+// src/base/logger/logger.ts
+var logsPath = getLogsPath();
+fs2.mkdirSync(path4.dirname(logsPath), {
+  recursive: true
+});
+fs2.writeFileSync(logsPath, "");
+function getString(obj) {
+  if (typeof obj === "string") {
+    return obj;
+  } else if (obj instanceof Error) {
+    return obj.message;
+  } else {
+    return JSON.stringify(obj);
+  }
+}
+__name(getString, "getString");
+function setLogColor(level, message) {
+  switch (level) {
+    case LogLevel.INFO:
+      return chalk.blue(message);
+    case LogLevel.WARN:
+      return chalk.yellow(message);
+    case LogLevel.ERROR:
+      return chalk.red(message);
+    case LogLevel.DEBUG:
+      return chalk.gray(message);
+  }
+}
+__name(setLogColor, "setLogColor");
+var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
+  static logger;
+  metadata = {};
+  constructor({ metadata, parentLogger } = {}) {
+    if (!_Logger.logger) {
+      _Logger.logger = winston.createLogger({
+        transports: [
+          inkTransport,
+          // Combined log file
+          new winston.transports.File({
+            filename: logsPath,
+            format: winston.format.combine(winston.format.timestamp(), winston.format.json())
+          })
+        ]
+      });
+    }
+    this.metadata = {};
+    if (parentLogger) {
+      this.metadata = {
+        ...this.metadata,
+        ...parentLogger.metadata
+      };
+    }
+    if (metadata) this.metadata = {
+      ...this.metadata,
+      ...metadata
+    };
+  }
+  log(level, message, details = {}) {
+    const service = this.metadata?.service;
+    const prefix = service ? `[${service}] ` : "";
+    const formattedMessage = prefix + setLogColor(level, getString(message));
+    const metadata = {
+      ...this.metadata,
+      id: crypto.randomUUID(),
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      // message: formattedMessage,
+      details
+    };
+    if (level === LogLevel.ERROR) {
+      _Logger.logger.error(formattedMessage, metadata);
+    } else if (level === LogLevel.WARN) {
+      _Logger.logger.warn(formattedMessage, metadata);
+    } else if (level === LogLevel.DEBUG) {
+      _Logger.logger.debug(formattedMessage, metadata);
+    } else {
+      _Logger.logger.info(formattedMessage, metadata);
+    }
+  }
+  info(message, details) {
+    this.log(LogLevel.INFO, message, details);
+  }
+  warn(message, details) {
+    this.log(LogLevel.WARN, message, details);
+  }
+  error(message, details) {
+    this.log(LogLevel.ERROR, message, details);
+  }
+  debug(message, details) {
+    this.log(LogLevel.DEBUG, message, details);
+  }
+  // Create a child logger with additional metadata
+  createChild(additionalMetadata) {
+    return new _Logger({
+      metadata: additionalMetadata,
+      parentLogger: this
+    });
+  }
+};
+var globalLogger = new Logger();
+
+// src/utils/metadata.ts
+async function cleanAndTagFlac(filePath, metadata) {
+  globalLogger.info(`--- Step 1: Cleaning invalid ID3 tags from ${filePath} ---`);
+  try {
+    const success = NodeId3.removeTags(filePath);
+    if (success) {
+      globalLogger.info("Successfully removed invalid ID3 tags. \u2705");
+    } else {
+      globalLogger.info("File did not contain any ID3 tags to remove.");
+    }
+  } catch (err) {
+    globalLogger.error(`Error cleaning file: ${err.message}. Stopping.`);
+    return;
+  }
+  globalLogger.info(`
+--- Step 2: Writing correct FLAC metadata ---`);
+  try {
+    const currentTags = await readFlacTags(filePath);
+    const newTags = {
+      ...currentTags.tagMap,
+      TITLE: metadata.trackTitle,
+      ARTIST: metadata.artists,
+      ALBUMARTIST: metadata.albumArtists ?? metadata.artists,
+      ...metadata.albumName ? {
+        ALBUM: metadata.albumName
+      } : {},
+      ...metadata.year ? {
+        YEAR: metadata.year,
+        DATE: metadata.year
+      } : {},
+      ...metadata.trackNumber ? {
+        TRACKNUMBER: metadata.trackNumber
+      } : {},
+      ...metadata.isrc ? {
+        ISRC: metadata.isrc
+      } : {},
+      ...metadata.genres?.length ? {
+        GENRE: metadata.genres
+      } : {},
+      ...metadata.bpm != null ? {
+        BPM: String(metadata.bpm)
+      } : {},
+      ...metadata.key ? {
+        KEY: metadata.key
+      } : {},
+      ...metadata.musicBrainzTrackId ? {
+        MUSICBRAINZ_TRACKID: metadata.musicBrainzTrackId
+      } : {},
+      ...metadata.musicBrainzAlbumId ? {
+        MUSICBRAINZ_ALBUMID: metadata.musicBrainzAlbumId
+      } : {},
+      ...metadata.musicBrainzArtistId ? {
+        MUSICBRAINZ_ARTISTID: metadata.musicBrainzArtistId
+      } : {},
+      ...metadata.musicBrainzReleaseGroupId ? {
+        MUSICBRAINZ_RELEASEGROUPID: metadata.musicBrainzReleaseGroupId
+      } : {}
+    };
+    const tagsToWrite = {
+      ...currentTags,
+      tagMap: newTags
+    };
+    await writeFlacTags(tagsToWrite, filePath);
+    globalLogger.info("FLAC metadata updated successfully! \u2705");
+  } catch (error) {
+    const err = error;
+    globalLogger.error(`Error writing FLAC metadata: ${err.message}`);
+    if (err.message === "Invalid stream header") {
+      globalLogger.error("This is unexpected, the file should be clean.");
+    }
+  }
+}
+__name(cleanAndTagFlac, "cleanAndTagFlac");
+async function moveFile(srcPath, destPath) {
+  await fs3.promises.mkdir(path5.dirname(destPath), {
+    recursive: true
+  });
+  try {
+    await fs3.promises.rename(srcPath, destPath);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      await fs3.promises.copyFile(srcPath, destPath);
+      await fs3.promises.unlink(srcPath);
+    } else {
+      throw err;
+    }
+  }
+}
+__name(moveFile, "moveFile");
+
+export {
+  __name,
+  deepMerge,
+  SettingsStore,
+  inkTransport,
+  getCacheDir,
+  getBinDir,
+  globalLogger,
+  cleanAndTagFlac,
+  moveFile
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

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

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { render, Instance } from 'ink';
+
+type WithFullScreen = (...args: Parameters<typeof render>) => {
+    instance: Instance;
+    start: () => Promise<void>;
+    waitUntilExit: () => Promise<void>;
+};
+declare const withFullScreen: WithFullScreen;
+declare function start(): void;
+declare const GoblinMalin: {
+    start: typeof start;
+};
+
+export { GoblinMalin as default, start, withFullScreen };

package/dist/index.js

@@ -0,0 +1,11 @@
+import {
+  src_default,
+  start,
+  withFullScreen
+} from "./chunk-DJTET7PY.js";
+import "./chunk-ECLAXOR2.js";
+export {
+  src_default as default,
+  start,
+  withFullScreen
+};

package/dist/metadata-Y5IDFTMA.js

@@ -0,0 +1,8 @@
+import {
+  cleanAndTagFlac,
+  moveFile
+} from "./chunk-ECLAXOR2.js";
+export {
+  cleanAndTagFlac,
+  moveFile
+};

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "goblin-malin",
+  "version": "0.1.0",
+  "description": "A keyboard-driven terminal UI for downloading and tagging music tracks with metadata from Spotify and YouTube",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "goblin-malin": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "start": "ts-node src/index.ts",
+    "build": "tsup",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "tsup"
+  },
+  "keywords": [
+    "music",
+    "download",
+    "downloader",
+    "tui",
+    "cli",
+    "terminal",
+    "spotify",
+    "youtube",
+    "yt-dlp",
+    "metadata",
+    "tags",
+    "ink",
+    "react"
+  ],
+  "author": "Tetraxel",
+  "license": "SEE LICENSE IN LICENSE",
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/dotenv": "^8.2.3",
+    "@types/ink": "^2.0.3",
+    "@types/ink-select-input": "^3.0.5",
+    "@types/ink-spinner": "^3.0.5",
+    "@types/ink-text-input": "^2.0.5",
+    "@types/node": "^25.6.2",
+    "@types/react": "^19.2.14",
+    "@swc/core": "^1.10.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "7zip-bin": "^5.2.0",
+    "@spotify/web-api-ts-sdk": "^1.2.0",
+    "adm-zip": "^0.5.17",
+    "chalk": "^5.6.2",
+    "clipboardy": "^5.3.1",
+    "dotenv": "^17.4.2",
+    "flac-tagger": "^2.0.0",
+    "flat-cache": "^6.1.22",
+    "fullscreen-ink": "^0.1.0",
+    "ink": "^7.0.2",
+    "ink-big-text": "^2.0.0",
+    "ink-form": "^2.0.1",
+    "ink-gradient": "^4.0.0",
+    "ink-link": "^5.0.0",
+    "ink-picture": "^1.3.5",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "musicbrainz-api": "^1.2.1",
+    "node-id3": "^0.2.9",
+    "open": "^11.0.0",
+    "react": "^19.2.6",
+    "slsk-client": "^1.1.0",
+    "winston": "^3.19.0",
+    "winston-transport": "^4.9.0",
+    "ytdlp-nodejs": "^3.4.4",
+    "ytmusic-api": "^5.3.1"
+  }
+}