@involvex/youtube-music-cli 0.0.20 → 0.0.21

package/CHANGELOG.md

@@ -1,3 +1,5 @@
+## [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

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();
@@ -75,6 +78,19 @@ function MainLayout() {
             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]);
@@ -91,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(() => {
@@ -127,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 {};

package/dist/source/services/version-check/version-check.service.js

@@ -0,0 +1,121 @@
+// Version check service for npm registry updates
+import { APP_NAME, APP_VERSION } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+class VersionCheckService {
+    static instance;
+    NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+    CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+    constructor() { }
+    static getInstance() {
+        if (!VersionCheckService.instance) {
+            VersionCheckService.instance = new VersionCheckService();
+        }
+        return VersionCheckService.instance;
+    }
+    /**
+     * Compare two semantic version strings
+     * Returns: 1 if a > b, -1 if a < b, 0 if equal
+     */
+    compareVersions(a, b) {
+        const parseVersion = (v) => {
+            // Remove 'v' prefix if present and split by non-numeric chars
+            const clean = v.replace(/^v/i, '');
+            return clean.split(/[.-]/).map(part => {
+                const num = parseInt(part, 10);
+                return Number.isNaN(num) ? 0 : num;
+            });
+        };
+        const partsA = parseVersion(a);
+        const partsB = parseVersion(b);
+        const maxLength = Math.max(partsA.length, partsB.length);
+        for (let i = 0; i < maxLength; i++) {
+            const partA = partsA[i] ?? 0;
+            const partB = partsB[i] ?? 0;
+            if (partA > partB)
+                return 1;
+            if (partA < partB)
+                return -1;
+        }
+        return 0;
+    }
+    /**
+     * Check if a version check should be performed (once per 24 hours)
+     */
+    shouldCheck(lastCheck) {
+        if (!lastCheck)
+            return true;
+        try {
+            const lastCheckDate = new Date(lastCheck);
+            const now = new Date();
+            const diff = now.getTime() - lastCheckDate.getTime();
+            return diff >= this.CHECK_INTERVAL;
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Mark that a version check has been performed
+     * Returns the timestamp string to store
+     */
+    markChecked() {
+        return new Date().toISOString();
+    }
+    /**
+     * Check npm registry for available updates
+     */
+    async checkForUpdates(currentVersion = APP_VERSION) {
+        try {
+            logger.debug('VersionCheckService', 'Checking for updates', {
+                package: APP_NAME,
+                currentVersion,
+            });
+            const url = `${this.NPM_REGISTRY_URL}/${APP_NAME}`;
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(5000), // 5 second timeout
+            });
+            if (!response.ok) {
+                logger.warn('VersionCheckService', 'Failed to fetch package info', {
+                    status: response.status,
+                });
+                return {
+                    hasUpdate: false,
+                    currentVersion,
+                    latestVersion: currentVersion,
+                };
+            }
+            const data = (await response.json());
+            const latestVersion = data['dist-tags']?.latest;
+            if (!latestVersion) {
+                logger.warn('VersionCheckService', 'No latest version found in response');
+                return {
+                    hasUpdate: false,
+                    currentVersion,
+                    latestVersion: currentVersion,
+                };
+            }
+            const hasUpdate = this.compareVersions(latestVersion, currentVersion) > 0;
+            logger.info('VersionCheckService', 'Version check complete', {
+                currentVersion,
+                latestVersion,
+                hasUpdate,
+            });
+            return {
+                hasUpdate,
+                currentVersion,
+                latestVersion,
+            };
+        }
+        catch (error) {
+            logger.error('VersionCheckService', 'Error checking for updates', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                hasUpdate: false,
+                currentVersion,
+                latestVersion: currentVersion,
+            };
+        }
+    }
+}
+export const getVersionCheckService = () => VersionCheckService.getInstance();

package/dist/source/types/actions.d.ts

@@ -130,3 +130,6 @@ export interface SetSearchLimitAction {
 export interface TogglePlayerModeAction {
     readonly category: 'TOGGLE_PLAYER_MODE';
 }
+export interface DetachAction {
+    readonly category: 'DETACH';
+}

package/dist/source/types/config.types.d.ts

@@ -36,4 +36,11 @@ export interface Config {
     downloadDirectory?: string;
     downloadFormat?: DownloadFormat;
     webServer?: WebServerConfig;
+    backgroundPlayback?: {
+        enabled: boolean;
+        ipcPath?: string;
+        currentUrl?: string;
+        timestamp?: string;
+    };
+    lastVersionCheck?: string;
 }

package/dist/source/types/navigation.types.d.ts

@@ -1,4 +1,4 @@
-import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction, TogglePlayerModeAction } from './actions.ts';
+import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction, TogglePlayerModeAction, DetachAction } from './actions.ts';
 export interface NavigationState {
     currentView: string;
     previousView: string | null;
@@ -12,4 +12,4 @@ export interface NavigationState {
     history: string[];
     playerMode: 'full' | 'mini';
 }
-export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction | TogglePlayerModeAction;
+export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction | TogglePlayerModeAction | DetachAction;

package/dist/source/utils/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const APP_NAME = "@involvex/youtube-music-cli";
-export declare const APP_VERSION = "0.0.1";
+export declare const APP_VERSION = "0.0.20";
 export declare const CONFIG_DIR: string;
 export declare const CONFIG_FILE: string;
 export declare const VIEW: {
@@ -19,6 +19,7 @@ export declare const VIEW: {
     readonly TRENDING: "trending";
     readonly EXPLORE: "explore";
     readonly IMPORT: "import";
+    readonly EXPORT_PLAYLISTS: "export_playlists";
 };
 export declare const SEARCH_TYPE: {
     readonly ALL: "all";
@@ -35,6 +36,7 @@ export declare const KEYBINDINGS: {
     readonly SUGGESTIONS: readonly ["g"];
     readonly SETTINGS: readonly [","];
     readonly PLUGINS: readonly ["p"];
+    readonly DETACH: readonly ["shift+q"];
     readonly PLAY_PAUSE: readonly [" "];
     readonly NEXT: readonly ["n", "right"];
     readonly PREVIOUS: readonly ["b", "left"];

package/dist/source/utils/constants.js

@@ -1,6 +1,6 @@
 // Application constants
 export const APP_NAME = '@involvex/youtube-music-cli';
-export const APP_VERSION = '0.0.1';
+export const APP_VERSION = '0.0.20';
 // Config directory
 export const CONFIG_DIR = process.platform === 'win32'
     ? `${process.env['USERPROFILE']}\\.youtube-music-cli`
@@ -24,6 +24,7 @@ export const VIEW = {
     TRENDING: 'trending',
     EXPLORE: 'explore',
     IMPORT: 'import',
+    EXPORT_PLAYLISTS: 'export_playlists',
 };
 // Search types
 export const SEARCH_TYPE = {
@@ -43,6 +44,7 @@ export const KEYBINDINGS = {
     SUGGESTIONS: ['g'],
     SETTINGS: [','],
     PLUGINS: ['p'],
+    DETACH: ['shift+q'],
     // Player
     PLAY_PAUSE: [' '],
     NEXT: ['n', 'right'],

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.20",
+	"version": "0.0.21",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",