playlist-admin 2.6.76

package/cli/index.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { loadConfig } from './lib/config.js';
+import { PipelineOrchestrator } from './lib/pipeline.js';
+import { PodcastPipeline } from './lib/podcast.js';
+import { SpotubeController } from './lib/spotube.js';
+import { cleanupMp3 } from './lib/cleanup.js';
+
+const HELP = `Playlist Administrator CLI (Node)
+
+Usage:
+  playlist-admin pipeline                   Run full pipeline
+  playlist-admin pipeline --step N          Run single step
+  playlist-admin spotube-download <name>    Download one playlist
+  playlist-admin spotube-download-all       Download all playlists
+  playlist-admin spotube-move               Move M4A files
+  playlist-admin spotube-cleanup            Remove metadata-renamed mp3 duplicates
+  playlist-admin podcast                    Run podcast pipeline
+  playlist-admin status                     Show status
+`;
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx >= 0 && idx + 1 < args.length) {
+    return parseInt(args[idx + 1], 10) || 0;
+  }
+  return 0;
+}
+
+const onProgress = () => {};
+const isCancelled = () => false;
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log(HELP);
+    return;
+  }
+
+  const config = loadConfig();
+  const cmd = args[0];
+
+  switch (cmd) {
+    case 'pipeline': {
+      const fromStep = getFlag(args, '--step');
+      const orch = new PipelineOrchestrator({ config, onLog: (m) => console.log(m), onProgress, isCancelled });
+      await orch.run({ fromStep });
+      break;
+    }
+
+    case 'spotube-download': {
+      if (args.length < 2) {
+        console.log('Usage: playlist-admin spotube-download <playlist_name>');
+        return;
+      }
+      const ctrl = new SpotubeController({
+        libraryPath: config.libraryPath,
+        coords: config.spotubeCoords,
+      });
+      if (!(await ctrl.isRunning())) {
+        console.log('Spotube is not running');
+        return;
+      }
+      await ctrl.downloadPlaylist(args[1]);
+      break;
+    }
+
+    case 'spotube-download-all': {
+      const ctrl = new SpotubeController({
+        libraryPath: config.libraryPath,
+        coords: config.spotubeCoords,
+      });
+      if (!(await ctrl.isRunning())) {
+        console.log('Spotube is not running');
+        return;
+      }
+      const names = Object.values(config.urlNames);
+      for (const name of names) {
+        console.log(`Downloading: ${name}`);
+        await ctrl.downloadPlaylist(name);
+      }
+      break;
+    }
+
+    case 'spotube-move': {
+      const ctrl = new SpotubeController({ libraryPath: config.libraryPath });
+      const moved = await ctrl.moveDownloads(config.resolvedSpotubeDownloadPath);
+      console.log(`Moved ${moved} files`);
+      break;
+    }
+
+    case 'spotube-cleanup': {
+      await cleanupMp3(config.libraryPath);
+      break;
+    }
+
+    case 'podcast': {
+      const pipeline = new PodcastPipeline({ config, onLog: (m) => console.log(m), isCancelled });
+      await pipeline.run();
+      break;
+    }
+
+    case 'status': {
+      console.log(`Library: ${config.libraryPath}`);
+      console.log(`Playlists: ${Object.keys(config.urlNames).length}`);
+      console.log(`Downloaded: ${Object.keys(config.lastUpdated || {}).length}`);
+      break;
+    }
+
+    default:
+      console.log(`Unknown command: ${cmd}\n`);
+      console.log(HELP);
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/cli/lib/audio_converter.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { run } from './util.js';
+import { readMetadata } from './metadata.js';
+
+// Port of lib/services/audio_converter.dart
+export async function convert({ inputPath, outputPath, format = 'mp3', ffmpegPath, meta = null, isCancelled }) {
+  let ffmpeg = ffmpegPath || 'ffmpeg';
+  if (ffmpeg.includes('\\') || ffmpeg.includes('/')) {
+    if (!fs.existsSync(ffmpeg)) ffmpeg = 'ffmpeg';
+  }
+  if (!fs.existsSync(inputPath)) return { ok: false, lufs: null };
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+
+  if (inputPath.toLowerCase().endsWith(`.${format}`)) {
+    fs.copyFileSync(inputPath, outputPath);
+    return { ok: true, lufs: null };
+  }
+
+  if (!meta) meta = await readMetadata(inputPath, { ffmpegPath });
+
+  const args = [
+    '-y', '-i', inputPath,
+    '-map_metadata', '0',
+    '-id3v2_version', '3',
+    '-threads', '0',
+  ];
+  if (format === 'mp3') {
+    args.push('-af', 'loudnorm=I=-14:TP=-1:LRA=7', '-filter_threads', '0');
+  }
+  args.push('-codec:a', format === 'mp3' ? 'libmp3lame' : 'flac', '-q:a', '0', outputPath);
+
+  try {
+    const result = await run(ffmpeg, args, { timeout: 600000 });
+    if (result.code !== 0) return { ok: false, lufs: null };
+    const m = result.stderr.match(/Input Integrated:\s+([-\d.]+)/);
+    const lufs = m ? parseFloat(m[1]) : null;
+    return { ok: true, lufs };
+  } catch {
+    return { ok: false, lufs: null };
+  }
+}

package/cli/lib/cleanup.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { stemOf } from './util.js';
+
+// Port of _cleanupMp3 from lib/cli_main.dart
+export async function cleanupMp3(libPath) {
+  const m4aDir = path.join(libPath, 'm4a');
+  const mp3Dir = path.join(libPath, 'mp3');
+  if (!fs.existsSync(m4aDir) || !fs.existsSync(mp3Dir)) {
+    console.log('錯誤：找不到 mp3 或 m4a 目錄');
+    return;
+  }
+
+  const m4aStems = new Set();
+  for (const f of fs.readdirSync(m4aDir)) {
+    if (f.toLowerCase().endsWith('.m4a')) {
+      m4aStems.add(stemOf(f).toLowerCase());
+    }
+  }
+  console.log(`M4A 檔案數: ${m4aStems.size}`);
+
+  const orphans = [];
+  for (const f of fs.readdirSync(mp3Dir)) {
+    if (f.toLowerCase().endsWith('.mp3')) {
+      const stem = stemOf(f).toLowerCase();
+      if (!m4aStems.has(stem)) {
+        orphans.push(path.join(mp3Dir, f));
+      }
+    }
+  }
+
+  if (orphans.length === 0) {
+    console.log('✅ 沒有發現孤兒 MP3');
+    return;
+  }
+
+  console.log(`\n⚠️  找到 ${orphans.length} 個 metadata 更名版的孤兒 MP3：\n`);
+  let totalSize = 0;
+  for (const f of orphans) {
+    const stat = fs.statSync(f);
+    totalSize += stat.size;
+    console.log(`  ${path.basename(f)}  (${(stat.size / 1024 / 1024).toFixed(1)} MB)`);
+  }
+  console.log(`\n  總計: ${(totalSize / 1024 / 1024).toFixed(1)} MB\n`);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => rl.question('是否刪除？(y/N): ', resolve));
+  rl.close();
+  const input = (answer || '').trim().toLowerCase();
+  if (input === 'y') {
+    let deleted = 0;
+    for (const f of orphans) {
+      fs.unlinkSync(f);
+      deleted++;
+    }
+    console.log(`✅ 已刪除 ${deleted} 個檔案`);
+  } else {
+    console.log('跳過刪除');
+  }
+}

package/cli/lib/config.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function appDataDir() {
+  return path.join(
+    process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'),
+    'Playlist Administrator',
+    'data',
+  );
+}
+
+export function loadConfig() {
+  // 1. Pointer file: LOCALAPPDATA\Playlist Administrator\data\config.json
+  const pointerFile = path.join(appDataDir(), 'config.json');
+  let basePath = '';
+  if (fs.existsSync(pointerFile)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(pointerFile, 'utf-8'));
+      basePath = data.base_path || '';
+    } catch {}
+  }
+
+  // 2. Main config: <base_path>\config.json
+  const mainFile = basePath ? path.join(basePath, 'config.json') : '';
+  const cfg = {};
+  if (mainFile && fs.existsSync(mainFile)) {
+    try {
+      Object.assign(cfg, JSON.parse(fs.readFileSync(mainFile, 'utf-8')));
+    } catch {}
+  } else if (fs.existsSync(pointerFile)) {
+    try {
+      Object.assign(cfg, JSON.parse(fs.readFileSync(pointerFile, 'utf-8')));
+    } catch {}
+  }
+
+  cfg.base_path = cfg.base_path || basePath;
+
+  const config = {
+    basePath: cfg.base_path || '',
+    language: cfg.language || 'zh-TW',
+    audioFormat: cfg.audio_format || 'mp3',
+    maxThreads: cfg.max_threads || 4,
+    debugMode: !!cfg.debug_mode,
+    enableMetadataEnrichment: !!cfg.enable_metadata_enrichment,
+    spotubeExactMatch: cfg.spotube_exact_match !== false,
+    spotubeConvertMatchedOnly: !!cfg.spotube_convert_matched_only,
+    ffmpegPath: cfg.ffmpeg_path || 'bin/ffmpeg.exe',
+    spotubeExePath: cfg.spotube_exe_path || '',
+    spotubeDownloadPath: cfg.spotube_download_path || '',
+    spotubeFolderName: cfg.spotube_folder_name || 'spotube',
+    lyricsFolderName: cfg.lyrics_folder_name || 'Lyrics',
+    autoUpdateCheck: cfg.auto_update_check !== false,
+    autoDownloadUpdate: !!cfg.auto_download_update,
+    enableRetroactiveLyrics: !!cfg.enable_retroactive_lyrics,
+    theme: cfg.theme || 'dark',
+    skippedVersion: cfg.skipped_version || '',
+    setupCompleted: !!cfg.setup_completed,
+    groqApiKey: cfg.groq_api_key || '',
+    groqConcurrency: cfg.groq_concurrency || 3,
+    podcastSubscriptions: cfg.podcast_subscriptions || {},
+    podcastHistory: cfg.podcast_history || {},
+    urlNames: cfg.url_names || {},
+    searchNames: cfg.search_names || {},
+    spotubeCoords: cfg.spotube_coords || {},
+    lastUpdated: cfg.last_updated || {},
+    lyricsOffsets: cfg.lyrics_offsets || {},
+  };
+
+  if (config.basePath) derivePaths(config);
+  return config;
+}
+
+export function saveConfig(config) {
+  if (!config.basePath) return;
+  const path_ = path.join(config.basePath, 'config.json');
+  const lock = `${path_}.lock`;
+  // File lock to prevent concurrent writes (wait up to ~10s)
+  for (let i = 0; i < 100 && fs.existsSync(lock); i++) {
+    sleepSync(100);
+  }
+  if (fs.existsSync(lock)) {
+    try { fs.unlinkSync(lock); } catch {}
+  }
+  try {
+    fs.writeFileSync(lock, '');
+    const json = {};
+    for (const [k, v] of Object.entries(config)) {
+      json[k] = v;
+    }
+    json.spotify_urls = Object.keys(config.urlNames);
+    fs.writeFileSync(path_, JSON.stringify(json, null, 2), 'utf-8');
+  } finally {
+    try { fs.unlinkSync(lock); } catch {}
+  }
+  // Update pointer file
+  const dir = appDataDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, 'config.json'),
+    JSON.stringify({ base_path: config.basePath, language: config.language }),
+    'utf-8',
+  );
+}
+
+function sleepSync(ms) {
+  const sw = Date.now();
+  while (Date.now() - sw < ms) { /* spin */ }
+}
+
+function derivePaths(config) {
+  const base = path.normalize(config.basePath);
+  const music = path.join(base, 'Music');
+  config.libraryPath = fs.existsSync(music) ? music : base;
+  config.playlistsPath = path.join(base, 'Playlists');
+  config.exportPath = path.join(base, 'USB_Output');
+  config.lyricsPath = path.join(config.libraryPath, config.lyricsFolderName);
+
+  const m4a = path.join(config.libraryPath, 'm4a');
+  if (!fs.existsSync(m4a) && fs.existsSync(path.join(base, 'm4a'))) {
+    config.m4aPath = path.join(base, 'm4a');
+  } else {
+    config.m4aPath = m4a;
+  }
+  const mp3 = path.join(config.libraryPath, 'mp3');
+  if (!fs.existsSync(mp3) && fs.existsSync(path.join(base, 'mp3'))) {
+    config.mp3Path = path.join(base, 'mp3');
+  } else {
+    config.mp3Path = mp3;
+  }
+
+  if (config.spotubeDownloadPath && config.spotubeDownloadPath.trim()) {
+    config.resolvedSpotubeDownloadPath = config.spotubeDownloadPath;
+  } else {
+    const folder = config.spotubeFolderName || 'spotube';
+    config.resolvedSpotubeDownloadPath = path.join(os.homedir(), 'Downloads', folder);
+  }
+}