@involvex/youtube-music-cli 0.0.19 → 0.0.21

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.21](https://github.com/involvex/youtube-music-cli/compare/v0.0.20...v0.0.21) (2026-02-20)
+
+## [0.0.20](https://github.com/involvex/youtube-music-cli/compare/v0.0.19...v0.0.20) (2026-02-20)
+
+### Bug Fixes
+
+- keyboard shortcut conflicts and web UI TypeScript errors ([af01f16](https://github.com/involvex/youtube-music-cli/commit/af01f16a151416c15891e44bb1eee3696a1ddc0e))
+
 ## [0.0.19](https://github.com/involvex/youtube-music-cli/compare/v0.0.18...v0.0.19) (2026-02-20)
 
 ## [0.0.18](https://github.com/involvex/youtube-music-cli/compare/v0.0.17...v0.0.18) (2026-02-18)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 involvex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/source/cli.js

@@ -9,6 +9,9 @@ import { getPluginRegistryService } from "./services/plugin/plugin-registry.serv
 import { getImportService } from "./services/import/import.service.js";
 import { getWebServerManager } from "./services/web/web-server-manager.js";
 import { getWebStreamingService } from "./services/web/web-streaming.service.js";
+import { getVersionCheckService } from "./services/version-check/version-check.service.js";
+import { getConfigService } from "./services/config/config.service.js";
+import { APP_VERSION } from "./utils/constants.js";
 const cli = meow(`
 	Usage
 	  $ youtube-music-cli
@@ -350,6 +353,24 @@ else {
         })();
     }
     else {
+        // Check for updates before rendering the app (skip in web-only mode)
+        if (!cli.flags.webOnly) {
+            void (async () => {
+                const versionCheck = getVersionCheckService();
+                const config = getConfigService();
+                const lastCheck = config.getLastVersionCheck();
+                if (versionCheck.shouldCheck(lastCheck)) {
+                    const result = await versionCheck.checkForUpdates(APP_VERSION);
+                    config.setLastVersionCheck(versionCheck.markChecked());
+                    if (result.hasUpdate) {
+                        console.log('');
+                        console.log(` Update available: ${APP_VERSION} → ${result.latestVersion}`);
+                        console.log('Run: npm install -g @involvex/youtube-music-cli');
+                        console.log('');
+                    }
+                }
+            })();
+        }
         // Render the app
         render(_jsx(App, { flags: cli.flags }));
     }

package/dist/source/components/export/ExportLayout.d.ts

@@ -0,0 +1 @@
+export default function ExportLayout(): import("react/jsx-runtime").JSX.Element;

package/dist/source/components/export/ExportLayout.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Export layout component for playlist export
+import { useState, useCallback, useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { useTheme } from "../../hooks/useTheme.js";
+import { useNavigation } from "../../hooks/useNavigation.js";
+import { useKeyBinding } from "../../hooks/useKeyboard.js";
+import { KEYBINDINGS } from "../../utils/constants.js";
+import { getExportService, } from "../../services/export/export.service.js";
+import { getConfigService } from "../../services/config/config.service.js";
+const FORMATS = [
+    { key: 'json', label: 'JSON' },
+    { key: 'm3u8', label: 'M3U8' },
+    { key: 'both', label: 'Both (JSON + M3U8)' },
+];
+export default function ExportLayout() {
+    const { theme } = useTheme();
+    const { dispatch } = useNavigation();
+    const config = getConfigService();
+    const exportService = getExportService();
+    const [step, setStep] = useState('format');
+    const [selectedFormat, setSelectedFormat] = useState(2); // Default to 'both'
+    const [selectedPlaylist, setSelectedPlaylist] = useState(-1); // -1 means "Export All"
+    const [results, setResults] = useState([]);
+    const playlists = useMemo(() => config.get('playlists') || [], [config]);
+    const goBack = useCallback(() => {
+        if (step === 'format') {
+            dispatch({ category: 'GO_BACK' });
+        }
+        else if (step === 'playlist') {
+            setStep('format');
+        }
+        else if (step === 'result') {
+            setStep('format');
+            setResults([]);
+        }
+    }, [step, dispatch]);
+    const selectFormat = useCallback(() => {
+        setStep('playlist');
+    }, []);
+    const startExport = useCallback(async () => {
+        setStep('exporting');
+        const format = FORMATS[selectedFormat].key;
+        try {
+            if (selectedPlaylist === -1) {
+                // Export all playlists
+                const exportResults = await exportService.exportAllPlaylists(playlists, {
+                    format,
+                });
+                setResults(exportResults);
+            }
+            else {
+                // Export single playlist
+                const result = await exportService.exportPlaylist(playlists[selectedPlaylist], {
+                    format,
+                });
+                setResults([result]);
+            }
+        }
+        catch (error) {
+            setResults([
+                {
+                    playlistName: 'Error',
+                    success: false,
+                    files: [],
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            ]);
+        }
+        finally {
+            setStep('result');
+        }
+    }, [selectedFormat, selectedPlaylist, playlists, exportService]);
+    // Keyboard bindings
+    useKeyBinding(KEYBINDINGS.UP, () => {
+        if (step === 'format') {
+            setSelectedFormat(prev => Math.max(0, prev - 1));
+        }
+        else if (step === 'playlist') {
+            setSelectedPlaylist(prev => Math.max(-1, prev - 1));
+        }
+    });
+    useKeyBinding(KEYBINDINGS.DOWN, () => {
+        if (step === 'format') {
+            setSelectedFormat(prev => Math.min(FORMATS.length - 1, prev + 1));
+        }
+        else if (step === 'playlist') {
+            setSelectedPlaylist(prev => Math.min(playlists.length - 1, prev === -1 && playlists.length > 0 ? 0 : prev + 1));
+        }
+    });
+    useKeyBinding(KEYBINDINGS.SELECT, () => {
+        if (step === 'format')
+            selectFormat();
+        else if (step === 'playlist')
+            startExport();
+        else if (step === 'result')
+            goBack();
+    });
+    useKeyBinding(KEYBINDINGS.BACK, goBack);
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, paddingX: 1, children: [_jsx(Box, { borderStyle: "double", borderColor: theme.colors.secondary, paddingX: 1, marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.colors.primary, children: "Export Playlists" }) }), step === 'format' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: theme.colors.dim, children: "Select export format:" }), FORMATS.map((format, index) => (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: index === selectedFormat ? theme.colors.primary : undefined, color: index === selectedFormat
+                                ? theme.colors.background
+                                : theme.colors.text, bold: index === selectedFormat, children: [index === selectedFormat ? '► ' : '  ', format.label] }) }, format.key))), playlists.length === 0 && (_jsx(Box, { marginTop: 1, paddingX: 1, children: _jsx(Text, { color: theme.colors.error, children: "No playlists found. Create or import playlists first." }) }))] })), step === 'playlist' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: theme.colors.dim, children: "Select playlist to export:" }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedPlaylist === -1 ? theme.colors.primary : undefined, color: selectedPlaylist === -1
+                                ? theme.colors.background
+                                : theme.colors.text, bold: selectedPlaylist === -1, children: [selectedPlaylist === -1 ? '► ' : '  ', "Export All (", playlists.length, " playlists)"] }) }), playlists.map((playlist, index) => (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: index === selectedPlaylist ? theme.colors.primary : undefined, color: index === selectedPlaylist
+                                ? theme.colors.background
+                                : theme.colors.text, bold: index === selectedPlaylist, children: [index === selectedPlaylist ? '► ' : '  ', playlist.name, " (", playlist.tracks.length, " tracks)"] }) }, playlist.playlistId)))] })), step === 'exporting' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Text, { color: theme.colors.primary, children: "Exporting..." }), _jsx(Text, { color: theme.colors.dim, children: selectedPlaylist === -1
+                            ? `Exporting ${playlists.length} playlists...`
+                            : `Exporting ${playlists[selectedPlaylist]?.name || 'playlist'}...` })] })), step === 'result' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: theme.colors.success, bold: true, children: "Export completed!" }) }), results.map((result, index) => (_jsx(Box, { flexDirection: "column", gap: 1, paddingX: 1, children: result.success ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: theme.colors.success, children: ["\u2713 ", result.playlistName] }), result.files.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsx(Text, { color: theme.colors.dim, children: "Exported to:" }), result.files.map(file => (_jsxs(Text, { color: theme.colors.primary, children: ["\u2022 ", file] }, file)))] }))] })) : (_jsxs(Text, { color: theme.colors.error, children: ["\u2717 ", result.playlistName, ": ", result.error] })) }, index))), _jsx(Box, { marginTop: 1, paddingX: 1, children: _jsx(Text, { color: theme.colors.dim, children: "Press Enter to continue" }) })] })), step !== 'exporting' && step !== 'result' && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.dim, children: step === 'format'
+                        ? '↑↓ to select, Enter to continue, Esc/q to go back'
+                        : '↑↓ to select, Enter to export, Esc to go back' }) }))] }));
+}

package/dist/source/components/layouts/MainLayout.js

@@ -21,9 +21,12 @@ import KeybindingsLayout from "../config/KeybindingsLayout.js";
 import TrendingLayout from "./TrendingLayout.js";
 import ExploreLayout from "./ExploreLayout.js";
 import ImportLayout from "../import/ImportLayout.js";
+import ExportLayout from "../export/ExportLayout.js";
 import { KEYBINDINGS, VIEW } from "../../utils/constants.js";
 import { Box } from 'ink';
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import { getPlayerService } from "../../services/player/player.service.js";
+import { getConfigService } from "../../services/config/config.service.js";
 function MainLayout() {
     const { theme } = useTheme();
     const { state: navState, dispatch } = useNavigation();
@@ -64,11 +67,30 @@ function MainLayout() {
         dispatch({ category: 'NAVIGATE', view: VIEW.TRENDING });
     }, [dispatch]);
     const goToExplore = useCallback(() => {
-        dispatch({ category: 'NAVIGATE', view: VIEW.EXPLORE });
-    }, [dispatch]);
+        // Don't navigate to explore if we're in plugins view (e key is used for enable/disable there)
+        if (navState.currentView !== VIEW.PLUGINS) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.EXPLORE });
+        }
+    }, [dispatch, navState.currentView]);
     const goToImport = useCallback(() => {
-        dispatch({ category: 'NAVIGATE', view: VIEW.IMPORT });
-    }, [dispatch]);
+        // Don't navigate to import if we're in plugins view (i key is used for plugin install there)
+        if (navState.currentView !== VIEW.PLUGINS) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.IMPORT });
+        }
+    }, [dispatch, navState.currentView]);
+    const handleDetach = useCallback(() => {
+        // Detach mode: Exit CLI while keeping music playing
+        const player = getPlayerService();
+        const config = getConfigService();
+        // Get the IPC path and current URL before detaching
+        const { ipcPath, currentUrl } = player.detach();
+        // Save the background playback state if we have an active session
+        if (ipcPath && currentUrl) {
+            config.setBackgroundPlaybackState({ ipcPath, currentUrl });
+        }
+        // Exit the app
+        process.exit(0);
+    }, []);
     const togglePlayerMode = useCallback(() => {
         dispatch({ category: 'TOGGLE_PLAYER_MODE' });
     }, [dispatch]);
@@ -85,6 +107,7 @@ function MainLayout() {
     useKeyBinding(['T'], goToTrending);
     useKeyBinding(['e'], goToExplore);
     useKeyBinding(['i'], goToImport);
+    useKeyBinding(KEYBINDINGS.DETACH, handleDetach);
     // Memoize the view component to prevent unnecessary remounts
     // Only recreate when currentView actually changes
     const currentView = useMemo(() => {
@@ -121,6 +144,8 @@ function MainLayout() {
                 return _jsx(ExploreLayout, {}, "explore");
             case 'import':
                 return _jsx(ImportLayout, {}, "import");
+            case 'export_playlists':
+                return _jsx(ExportLayout, {}, "export_playlists");
             case 'help':
                 return _jsx(Help, {}, "help");
             default:

package/dist/source/components/settings/Settings.js

@@ -23,6 +23,7 @@ const SETTINGS_ITEMS = [
     'Download Format',
     'Sleep Timer',
     'Import Playlists',
+    'Export Playlists',
     'Custom Keybindings',
     'Manage Plugins',
 ];
@@ -120,9 +121,12 @@ export default function Settings() {
             dispatch({ category: 'NAVIGATE', view: VIEW.IMPORT });
         }
         else if (selectedIndex === 9) {
-            dispatch({ category: 'NAVIGATE', view: VIEW.KEYBINDINGS });
+            dispatch({ category: 'NAVIGATE', view: VIEW.EXPORT_PLAYLISTS });
         }
         else if (selectedIndex === 10) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.KEYBINDINGS });
+        }
+        else if (selectedIndex === 11) {
             dispatch({ category: 'NAVIGATE', view: VIEW.PLUGINS });
         }
     };
@@ -146,5 +150,5 @@ export default function Settings() {
                         ? theme.colors.background
                         : isActive
                             ? theme.colors.accent
-                            : theme.colors.text, bold: selectedIndex === 7, children: sleepTimerLabel }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 8 ? theme.colors.primary : undefined, color: selectedIndex === 8 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 8, children: "Import Playlists \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 9 ? theme.colors.primary : undefined, color: selectedIndex === 9 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 9, children: "Custom Keybindings \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 10 ? theme.colors.primary : undefined, color: selectedIndex === 10 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 10, children: "Manage Plugins" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.dim, children: "Arrows to navigate, Enter to select, Esc/q to go back" }) })] }));
+                            : theme.colors.text, bold: selectedIndex === 7, children: sleepTimerLabel }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 8 ? theme.colors.primary : undefined, color: selectedIndex === 8 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 8, children: "Import Playlists \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 9 ? theme.colors.primary : undefined, color: selectedIndex === 9 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 9, children: "Export Playlists \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 10 ? theme.colors.primary : undefined, color: selectedIndex === 10 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 10, children: "Custom Keybindings \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 11 ? theme.colors.primary : undefined, color: selectedIndex === 11 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 11, children: "Manage Plugins" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.dim, children: "Arrows to navigate, Enter to select, Esc/q to go back" }) })] }));
 }

package/dist/source/main.js

@@ -14,11 +14,31 @@ import { useNavigation } from "./hooks/useNavigation.js";
 import { usePlayer } from "./hooks/usePlayer.js";
 import { useYouTubeMusic } from "./hooks/useYouTubeMusic.js";
 import { VIEW } from "./utils/constants.js";
+import { getConfigService } from "./services/config/config.service.js";
+import { getPlayerService } from "./services/player/player.service.js";
+import { getNotificationService } from "./services/notification/notification.service.js";
 function Initializer({ flags }) {
     const { dispatch } = useNavigation();
     const { play } = usePlayer();
     const { getTrack, getPlaylist } = useYouTubeMusic();
     useEffect(() => {
+        // Check for background playback state on startup
+        const config = getConfigService();
+        const player = getPlayerService();
+        const backgroundState = config.getBackgroundPlaybackState();
+        if (backgroundState.enabled) {
+            // Show notification about background playback
+            const notification = getNotificationService();
+            notification.setEnabled(true);
+            void notification.notify('Background Playback Active', 'Press R to resume control');
+            // Try to reattach to the existing mpv process
+            if (backgroundState.ipcPath) {
+                void player.reattach(backgroundState.ipcPath).catch(() => {
+                    // Reattach failed, clear the state
+                    config.clearBackgroundPlaybackState();
+                });
+            }
+        }
         if (flags?.showSuggestions) {
             dispatch({ category: 'NAVIGATE', view: VIEW.SUGGESTIONS });
         }

package/dist/source/services/config/config.service.d.ts

@@ -23,6 +23,21 @@ declare class ConfigService {
     removeFavorite(trackId: string): void;
     isFavorite(trackId: string): boolean;
     getFavorites(): string[];
+    setBackgroundPlaybackState(state: {
+        ipcPath: string;
+        currentUrl: string;
+    }): void;
+    getBackgroundPlaybackState(): {
+        enabled: true;
+        ipcPath: string;
+        currentUrl: string;
+        timestamp: string;
+    } | {
+        enabled: false;
+    };
+    clearBackgroundPlaybackState(): void;
+    setLastVersionCheck(timestamp: string): void;
+    getLastVersionCheck(): string | undefined;
 }
 export declare function getConfigService(): ConfigService;
 export {};

package/dist/source/services/config/config.service.js

@@ -145,6 +145,37 @@ class ConfigService {
     getFavorites() {
         return this.config.favorites;
     }
+    setBackgroundPlaybackState(state) {
+        this.config.backgroundPlayback = {
+            enabled: true,
+            ipcPath: state.ipcPath,
+            currentUrl: state.currentUrl,
+            timestamp: new Date().toISOString(),
+        };
+        this.save();
+    }
+    getBackgroundPlaybackState() {
+        if (this.config.backgroundPlayback?.enabled) {
+            return {
+                enabled: true,
+                ipcPath: this.config.backgroundPlayback.ipcPath,
+                currentUrl: this.config.backgroundPlayback.currentUrl,
+                timestamp: this.config.backgroundPlayback.timestamp,
+            };
+        }
+        return { enabled: false };
+    }
+    clearBackgroundPlaybackState() {
+        this.config.backgroundPlayback = undefined;
+        this.save();
+    }
+    setLastVersionCheck(timestamp) {
+        this.config.lastVersionCheck = timestamp;
+        this.save();
+    }
+    getLastVersionCheck() {
+        return this.config.lastVersionCheck;
+    }
 }
 // Singleton instance
 let configServiceInstance = null;

package/dist/source/services/export/export.service.d.ts

@@ -0,0 +1,41 @@
+import type { Playlist } from '../../types/youtube-music.types.ts';
+export type ExportFormat = 'json' | 'm3u8' | 'both';
+export interface ExportOptions {
+    format: ExportFormat;
+    outputDir?: string;
+}
+export interface ExportResult {
+    playlistName: string;
+    format: ExportFormat;
+    files: string[];
+    success: boolean;
+    error?: string;
+}
+declare class ExportService {
+    private static instance;
+    private readonly DEFAULT_EXPORT_DIR;
+    private constructor();
+    static getInstance(): ExportService;
+    /**
+     * Get the export directory, create if it doesn't exist
+     */
+    private getExportDir;
+    /**
+     * Sanitize filename for safe file system usage
+     */
+    private sanitizeFilename;
+    /**
+     * Generate M3U8 format content for a playlist
+     */
+    private generateM3U8;
+    /**
+     * Export a single playlist to the specified format(s)
+     */
+    exportPlaylist(playlist: Playlist, options: ExportOptions): Promise<ExportResult>;
+    /**
+     * Export multiple playlists to the specified format(s)
+     */
+    exportAllPlaylists(playlists: Playlist[], options: ExportOptions): Promise<ExportResult[]>;
+}
+export declare const getExportService: () => ExportService;
+export {};

package/dist/source/services/export/export.service.js

@@ -0,0 +1,131 @@
+// Playlist export service for JSON and M3U8 formats
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+class ExportService {
+    static instance;
+    DEFAULT_EXPORT_DIR = `${CONFIG_DIR}/exports`;
+    constructor() { }
+    static getInstance() {
+        if (!ExportService.instance) {
+            ExportService.instance = new ExportService();
+        }
+        return ExportService.instance;
+    }
+    /**
+     * Get the export directory, create if it doesn't exist
+     */
+    getExportDir(customDir) {
+        const exportDir = customDir || this.DEFAULT_EXPORT_DIR;
+        if (!existsSync(exportDir)) {
+            try {
+                mkdirSync(exportDir, { recursive: true });
+                logger.info('ExportService', 'Created export directory', { exportDir });
+            }
+            catch (error) {
+                logger.error('ExportService', 'Failed to create export directory', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw new Error(`Failed to create export directory: ${exportDir}`);
+            }
+        }
+        return exportDir;
+    }
+    /**
+     * Sanitize filename for safe file system usage
+     */
+    sanitizeFilename(name) {
+        // Remove or replace characters that are unsafe for filenames
+        return name
+            .replace(/[<>:"/\\|?*]/g, '') // Remove unsafe chars
+            .replace(/\s+/g, '_') // Replace spaces with underscores
+            .substring(0, 200); // Limit length
+    }
+    /**
+     * Generate M3U8 format content for a playlist
+     */
+    generateM3U8(playlist) {
+        const lines = ['#EXTM3U', ''];
+        for (const track of playlist.tracks) {
+            if (track.artists && track.artists.length > 0) {
+                const artistNames = track.artists.map(a => a.name).join(', ');
+                const duration = track.duration
+                    ? Math.round(track.duration / 1000)
+                    : -1;
+                lines.push(`#EXTINF:${duration},${artistNames} - ${track.title}`);
+            }
+            else {
+                lines.push(`#EXTINF:-1,${track.title}`);
+            }
+            // Use the videoId to generate YouTube URL
+            if (track.videoId) {
+                lines.push(`https://www.youtube.com/watch?v=${track.videoId}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Export a single playlist to the specified format(s)
+     */
+    async exportPlaylist(playlist, options) {
+        try {
+            logger.info('ExportService', 'Exporting playlist', {
+                playlist: playlist.name,
+                format: options.format,
+            });
+            const exportDir = this.getExportDir(options.outputDir);
+            const sanitizedName = this.sanitizeFilename(playlist.name);
+            const files = [];
+            // Export to JSON
+            if (options.format === 'json' || options.format === 'both') {
+                const jsonPath = `${exportDir}/${sanitizedName}.json`;
+                const jsonContent = JSON.stringify(playlist, null, 2);
+                writeFileSync(jsonPath, jsonContent, 'utf-8');
+                files.push(jsonPath);
+                logger.info('ExportService', 'Exported to JSON', { path: jsonPath });
+            }
+            // Export to M3U8
+            if (options.format === 'm3u8' || options.format === 'both') {
+                const m3u8Path = `${exportDir}/${sanitizedName}.m3u8`;
+                const m3u8Content = this.generateM3U8(playlist);
+                writeFileSync(m3u8Path, m3u8Content, 'utf-8');
+                files.push(m3u8Path);
+                logger.info('ExportService', 'Exported to M3U8', { path: m3u8Path });
+            }
+            return {
+                playlistName: playlist.name,
+                format: options.format,
+                files,
+                success: true,
+            };
+        }
+        catch (error) {
+            logger.error('ExportService', 'Failed to export playlist', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                playlistName: playlist.name,
+                format: options.format,
+                files: [],
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Export multiple playlists to the specified format(s)
+     */
+    async exportAllPlaylists(playlists, options) {
+        logger.info('ExportService', 'Exporting all playlists', {
+            count: playlists.length,
+            format: options.format,
+        });
+        const results = [];
+        for (const playlist of playlists) {
+            const result = await this.exportPlaylist(playlist, options);
+            results.push(result);
+        }
+        return results;
+    }
+}
+export const getExportService = () => ExportService.getInstance();

package/dist/source/services/player/player.service.d.ts

@@ -54,6 +54,18 @@ declare class PlayerService {
     pause(): void;
     resume(): void;
     stop(): void;
+    /**
+     * Detach mode: Save state and clear references without killing mpv process
+     * Returns the IPC path and current URL for later reattachment
+     */
+    detach(): {
+        ipcPath: string | null;
+        currentUrl: string | null;
+    };
+    /**
+     * Reattach to an existing mpv process via IPC
+     */
+    reattach(ipcPath: string): Promise<void>;
     setVolume(volume: number): void;
     getVolume(): number;
     setSpeed(speed: number): void;

package/dist/source/services/player/player.service.js

@@ -360,6 +360,36 @@ class PlayerService {
         this.ipcPath = null;
         this.ipcConnectRetries = 0;
     }
+    /**
+     * Detach mode: Save state and clear references without killing mpv process
+     * Returns the IPC path and current URL for later reattachment
+     */
+    detach() {
+        logger.info('PlayerService', 'Detaching from player', {
+            ipcPath: this.ipcPath,
+            currentUrl: this.currentUrl,
+        });
+        const info = {
+            ipcPath: this.ipcPath,
+            currentUrl: this.currentUrl,
+        };
+        // Clear references but DON'T kill mpv process - it keeps playing
+        this.mpvProcess = null;
+        this.ipcSocket = null;
+        this.ipcPath = null;
+        this.isPlaying = false;
+        return info;
+    }
+    /**
+     * Reattach to an existing mpv process via IPC
+     */
+    async reattach(ipcPath) {
+        logger.info('PlayerService', 'Reattaching to player', { ipcPath });
+        this.ipcPath = ipcPath;
+        await this.connectIpc();
+        this.isPlaying = true;
+        logger.info('PlayerService', 'Successfully reattached to player');
+    }
     setVolume(volume) {
         logger.debug('PlayerService', 'setVolume() called', {
             oldVolume: this.currentVolume,

package/dist/source/services/version-check/version-check.service.d.ts

@@ -0,0 +1,32 @@
+export interface VersionCheckResult {
+    hasUpdate: boolean;
+    currentVersion: string;
+    latestVersion: string;
+}
+declare class VersionCheckService {
+    private static instance;
+    private readonly NPM_REGISTRY_URL;
+    private readonly CHECK_INTERVAL;
+    private constructor();
+    static getInstance(): VersionCheckService;
+    /**
+     * Compare two semantic version strings
+     * Returns: 1 if a > b, -1 if a < b, 0 if equal
+     */
+    private compareVersions;
+    /**
+     * Check if a version check should be performed (once per 24 hours)
+     */
+    shouldCheck(lastCheck: string | undefined): boolean;
+    /**
+     * Mark that a version check has been performed
+     * Returns the timestamp string to store
+     */
+    markChecked(): string;
+    /**
+     * Check npm registry for available updates
+     */
+    checkForUpdates(currentVersion?: string): Promise<VersionCheckResult>;
+}
+export declare const getVersionCheckService: () => VersionCheckService;
+export {};