playlist-admin 2.6.78 → 2.6.80

package/cli/lib/config.js

@@ -37,34 +37,34 @@ export function loadConfig() {
   cfg.base_path = cfg.base_path || basePath;
 
   const config = {
-    basePath: cfg.base_path || '',
+    basePath: cfg.base_path || cfg.basePath || '',
     language: cfg.language || 'zh-TW',
-    audioFormat: cfg.audio_format || 'mp3',
-    maxThreads: cfg.max_threads || 4,
+    audioFormat: cfg.audio_format || cfg.audioFormat || 'mp3',
+    maxThreads: cfg.max_threads || cfg.maxThreads || 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,
+    enableMetadataEnrichment: !!(cfg.enable_metadata_enrichment ?? cfg.enableMetadataEnrichment),
+    spotubeExactMatch: cfg.spotube_exact_match !== false && cfg.spotubeExactMatch !== false,
+    spotubeConvertMatchedOnly: !!(cfg.spotube_convert_matched_only ?? cfg.spotubeConvertMatchedOnly),
+    ffmpegPath: cfg.ffmpeg_path || cfg.ffmpegPath || 'bin/ffmpeg.exe',
+    spotubeExePath: cfg.spotube_exe_path || cfg.spotubeExePath || '',
+    spotubeDownloadPath: cfg.spotube_download_path || cfg.spotubeDownloadPath || '',
+    spotubeFolderName: cfg.spotube_folder_name || cfg.spotubeFolderName || 'spotube',
+    lyricsFolderName: cfg.lyrics_folder_name || cfg.lyricsFolderName || 'Lyrics',
+    autoUpdateCheck: cfg.auto_update_check !== false && cfg.autoUpdateCheck !== false,
+    autoDownloadUpdate: !!(cfg.auto_download_update ?? cfg.autoDownloadUpdate),
+    enableRetroactiveLyrics: !!(cfg.enable_retroactive_lyrics ?? cfg.enableRetroactiveLyrics),
     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 || {},
+    skippedVersion: cfg.skipped_version || cfg.skippedVersion || '',
+    setupCompleted: !!(cfg.setup_completed ?? cfg.setupCompleted),
+    groqApiKey: cfg.groq_api_key || cfg.groqApiKey || '',
+    groqConcurrency: cfg.groq_concurrency || cfg.groqConcurrency || 3,
+    podcastSubscriptions: cfg.podcast_subscriptions || cfg.podcastSubscriptions || {},
+    podcastHistory: cfg.podcast_history || cfg.podcastHistory || {},
+    urlNames: cfg.url_names || cfg.urlNames || {},
+    searchNames: cfg.search_names || cfg.searchNames || {},
+    spotubeCoords: cfg.spotube_coords || cfg.spotubeCoords || {},
+    lastUpdated: cfg.last_updated || cfg.lastUpdated || {},
+    lyricsOffsets: cfg.lyrics_offsets || cfg.lyricsOffsets || {},
   };
 
   if (config.basePath) derivePaths(config);
@@ -84,11 +84,39 @@ export function saveConfig(config) {
   }
   try {
     fs.writeFileSync(lock, '');
-    const json = {};
-    for (const [k, v] of Object.entries(config)) {
-      json[k] = v;
-    }
-    json.spotify_urls = Object.keys(config.urlNames);
+    // Write in the Python/Dart-compatible snake_case schema. Writing JS
+    // camelCase here would break the GUI/Flutter app (and this reader).
+    const json = {
+      base_path: config.basePath,
+      language: config.language,
+      audio_format: config.audioFormat,
+      max_threads: config.maxThreads,
+      debug_mode: config.debugMode,
+      enable_metadata_enrichment: config.enableMetadataEnrichment,
+      spotube_exact_match: config.spotubeExactMatch,
+      spotube_convert_matched_only: config.spotubeConvertMatchedOnly,
+      ffmpeg_path: config.ffmpegPath,
+      spotube_exe_path: config.spotubeExePath,
+      spotube_download_path: config.spotubeDownloadPath,
+      spotube_folder_name: config.spotubeFolderName,
+      lyrics_folder_name: config.lyricsFolderName,
+      auto_update_check: config.autoUpdateCheck,
+      auto_download_update: config.autoDownloadUpdate,
+      enable_retroactive_lyrics: config.enableRetroactiveLyrics,
+      theme: config.theme,
+      skipped_version: config.skippedVersion,
+      setup_completed: config.setupCompleted,
+      groq_api_key: config.groqApiKey,
+      groq_concurrency: config.groqConcurrency,
+      podcast_subscriptions: config.podcastSubscriptions,
+      podcast_history: config.podcastHistory,
+      url_names: config.urlNames,
+      search_names: config.searchNames,
+      spotube_coords: config.spotubeCoords,
+      last_updated: config.lastUpdated,
+      lyrics_offsets: config.lyricsOffsets,
+      spotify_urls: Object.keys(config.urlNames),
+    };
     fs.writeFileSync(path_, JSON.stringify(json, null, 2), 'utf-8');
   } finally {
     try { fs.unlinkSync(lock); } catch {}

package/cli/lib/lufs.js

@@ -15,7 +15,11 @@ export class LufsService {
   _load(fmt) {
     const data = readJson(this._cacheFile(fmt), {});
     const out = {};
-    for (const [k, v] of Object.entries(data)) out[k] = typeof v === 'number' ? v : parseFloat(v);
+    for (const [k, v] of Object.entries(data)) {
+      // GUI (Python/Dart) writes unnormalized keys like "...\Playlists\..\mp3\x.mp3".
+      // Normalize so lookups (already normalized) hit the existing cache.
+      out[path.normalize(k)] = typeof v === 'number' ? v : parseFloat(v);
+    }
     return out;
   }
 
@@ -24,6 +28,8 @@ export class LufsService {
   }
 
   _resolvePlaylistPath(entry, playlistsPath, basePath, libraryPath) {
+    let decodePath = (s) => { try { return decodeURIComponent(s); } catch { return s; } };
+    entry = decodePath(entry);
     if (!entry) return null;
     if (!entry.includes('.') && !entry.includes('\\') && !entry.includes('/')) return null;
     const resolved = path.join(playlistsPath, entry);

package/cli/lib/pipeline.js

@@ -269,6 +269,8 @@ export class PipelineOrchestrator {
   }
 
   _trackFileExists(entry) {
+    let decodePath = (s) => { try { return decodeURIComponent(s); } catch { return s; } };
+    entry = decodePath(entry);
     if (!entry.includes('.') && !entry.includes('\\')) return true;
     const relToPl = path.join(this.config.playlistsPath, entry);
     if (fs.existsSync(relToPl)) return true;
@@ -334,7 +336,8 @@ export class PipelineOrchestrator {
     for (const filePath of newUnsorted) {
       const absFilePath = path.resolve(filePath);
       sb += `#EXTINF:-1,${stemOf(filePath)}\n`;
-      sb += `${relativePath(absFilePath, absPlPath)}\n`;
+      // Echo Nightly compatible: URI-encode the relative path
+      sb += `${encodeURIComponent(relativePath(absFilePath, absPlPath)).replace(/%2F/g, '/')}\n`;
     }
 
     fs.writeFileSync(unsortedPath, sb, { flag: existingStems.size === 0 ? 'w' : 'a', encoding: 'utf-8' });

package/cli/lib/playlist_parser.js

@@ -2,6 +2,10 @@ import fs from 'node:fs';
 import { stemOf } from './util.js';
 
 // Port of lib/services/playlist_parser.dart
+function decodePath(s) {
+  try { return decodeURIComponent(s); } catch { return s; }
+}
+
 export class PlaylistParser {
   static isInternalPlaylist(name) {
     const n = name.toLowerCase();
@@ -31,7 +35,7 @@ export class PlaylistParser {
           const name = pathLine.includes('\\') || pathLine.includes('/')
             ? pathLine.replace(/[\\/]/g, '\\').split('\\').pop()
             : pathLine;
-          songs.push(name.replace(/\.[^.]+$/, ''));
+          songs.push(decodePath(name).replace(/\.[^.]+$/, ''));
           i = j + 1;
         } else {
           i++;
@@ -64,7 +68,7 @@ export class PlaylistParser {
         let j = i + 1;
         while (j < lines.length && (lines[j].startsWith('#') || lines[j].length === 0)) j++;
         if (j < lines.length) {
-          entries.push(lines[j]);
+          entries.push(decodePath(lines[j]));
           i = j + 1;
         } else {
           i++;

package/cli/lib/podcast.js

@@ -206,7 +206,10 @@ export class PodcastService {
 
   async searchPodcasts(query) {
     const url = `https://itunes.apple.com/search?term=${encodeURIComponent(query)}&media=podcast&limit=20`;
-    const resp = await fetch(url, { headers: { 'User-Agent': 'PlaylistAdministrator/2.0' } });
+    const resp = await fetch(url, {
+      headers: { 'User-Agent': 'PlaylistAdministrator/2.0' },
+      signal: AbortSignal.timeout(30000),
+    });
     if (resp.status !== 200) throw new Error(`搜尋失敗 (${resp.status})`);
     const data = await resp.json();
     return (data.results || [])

package/cli/lib/scraper.js

@@ -119,6 +119,7 @@ export class SpotifyScraper {
         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
         'Accept-Language': 'zh-TW,zh;q=0.9,en;q=0.5',
       },
+      signal: AbortSignal.timeout(60000),
     });
     if (resp.status !== 200) {
       this.log(`  HTTP ${resp.status}`);
@@ -220,7 +221,9 @@ export class SpotifyScraper {
         sb += `#EXTINF:-1,${localName}\n`;
         const absPath = path.resolve(matched);
         const absPl = path.resolve(path.dirname(m3uPath));
-        sb += `${relativePath(absPath, absPl)}\n`;
+        // Echo Nightly compatible: URI-encode the path (keep slashes)
+        const rel = encodeURIComponent(relativePath(absPath, absPl)).replace(/%2F/g, '/');
+        sb += `${rel}\n`;
         resolved++;
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playlist-admin",
-  "version": "2.6.78",
+  "version": "2.6.80",
   "description": "Playlist Administrator CLI - music library pipeline, podcast pipeline and Spotube automation (Node.js)",
   "type": "module",
   "bin": {