@involvex/youtube-music-cli 0.0.47 → 0.0.48

package/dist/source/services/player/dependency-check.service.js

@@ -1,140 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline/promises';
-const REQUIRED_DEPENDENCIES = ['mpv', 'yt-dlp'];
-function getDependencyExecutable(dependency) {
-    if (process.platform === 'win32') {
-        return dependency === 'mpv' ? 'mpv.exe' : 'yt-dlp.exe';
-    }
-    return dependency;
-}
-function renderInstallCommand(plan) {
-    return [plan.command, ...plan.args].join(' ');
-}
-function runCommand(command, args, options) {
-    return new Promise(resolve => {
-        const child = spawn(command, args, {
-            stdio: options.stdio,
-        });
-        child.once('error', () => {
-            resolve(false);
-        });
-        child.once('close', code => {
-            resolve(code === 0);
-        });
-    });
-}
-async function commandExists(command) {
-    return runCommand(command, ['--version'], { stdio: 'ignore' });
-}
-async function getMissingDependencies() {
-    const missing = [];
-    for (const dependency of REQUIRED_DEPENDENCIES) {
-        const executable = getDependencyExecutable(dependency);
-        const exists = await commandExists(executable);
-        if (!exists) {
-            missing.push(dependency);
-        }
-    }
-    return missing;
-}
-export function buildInstallPlan(platform, availableManagers, missingDependencies) {
-    if (missingDependencies.length === 0) {
-        return null;
-    }
-    const deps = [...missingDependencies];
-    const hasManager = (manager) => availableManagers.includes(manager);
-    if ((platform === 'darwin' || platform === 'linux') && hasManager('brew')) {
-        return { command: 'brew', args: ['install', ...deps] };
-    }
-    if (platform === 'win32') {
-        if (hasManager('scoop')) {
-            return { command: 'scoop', args: ['install', ...deps] };
-        }
-        if (hasManager('choco')) {
-            return { command: 'choco', args: ['install', ...deps, '-y'] };
-        }
-        return null;
-    }
-    if (platform === 'linux') {
-        if (hasManager('apt-get')) {
-            return {
-                command: 'sudo',
-                args: ['apt-get', 'install', '-y', ...deps],
-            };
-        }
-        if (hasManager('pacman')) {
-            return {
-                command: 'sudo',
-                args: ['pacman', '-S', '--needed', ...deps],
-            };
-        }
-        if (hasManager('dnf')) {
-            return {
-                command: 'sudo',
-                args: ['dnf', 'install', '-y', ...deps],
-            };
-        }
-    }
-    return null;
-}
-async function getAvailablePackageManagers(platform) {
-    const candidates = platform === 'win32'
-        ? ['scoop', 'choco']
-        : platform === 'darwin'
-            ? ['brew']
-            : ['brew', 'apt-get', 'pacman', 'dnf'];
-    const available = [];
-    for (const manager of candidates) {
-        if (await commandExists(manager)) {
-            available.push(manager);
-        }
-    }
-    return available;
-}
-function printManualInstallHelp(missing, plan) {
-    console.error(`\nMissing playback dependencies: ${missing.join(', ')}. Install them and re-run the command.`);
-    if (plan) {
-        console.error(`Suggested install command: ${renderInstallCommand(plan)}\n`);
-        return;
-    }
-    console.error('Suggested install commands:\n  macOS: brew install mpv yt-dlp\n  Windows: scoop install mpv yt-dlp\n  Linux (apt): sudo apt-get install -y mpv yt-dlp\n');
-}
-export async function ensurePlaybackDependencies(options) {
-    const missing = await getMissingDependencies();
-    if (missing.length === 0) {
-        return { ready: true, missing: [] };
-    }
-    const availableManagers = await getAvailablePackageManagers(process.platform);
-    const installPlan = buildInstallPlan(process.platform, availableManagers, missing);
-    if (!options.interactive || !installPlan) {
-        printManualInstallHelp(missing, installPlan);
-        return { ready: false, missing };
-    }
-    const prompt = `Missing ${missing.join(', ')}. Install now with "${renderInstallCommand(installPlan)}"? [Y/n] `;
-    const readline = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const response = (await readline.question(prompt)).trim().toLowerCase();
-    readline.close();
-    if (response === 'n' || response === 'no') {
-        printManualInstallHelp(missing, installPlan);
-        return { ready: false, missing };
-    }
-    console.log(`\nInstalling dependencies: ${missing.join(', ')}`);
-    const installSuccess = await runCommand(installPlan.command, installPlan.args, {
-        stdio: 'inherit',
-    });
-    if (!installSuccess) {
-        console.error('\nAutomatic installation failed.');
-        printManualInstallHelp(missing, installPlan);
-        return { ready: false, missing };
-    }
-    const missingAfterInstall = await getMissingDependencies();
-    if (missingAfterInstall.length > 0) {
-        printManualInstallHelp(missingAfterInstall, installPlan);
-        return { ready: false, missing: missingAfterInstall };
-    }
-    console.log('Playback dependencies installed successfully.\n');
-    return { ready: true, missing: [] };
-}

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

@@ -1,478 +0,0 @@
-// Audio playback service using mpv media player with IPC control
-import { spawn } from 'node:child_process';
-import { connect } from 'node:net';
-import { logger } from "../logger/logger.service.js";
-export function buildMpvArgs(url, ipcPath, options) {
-    const gapless = options.gaplessPlayback ?? true;
-    const crossfadeDuration = Math.max(0, options.crossfadeDuration ?? 0);
-    const fadeDuration = Math.max(0, options.volumeFadeDuration ?? 0);
-    const eqPreset = options.equalizerPreset ?? 'flat';
-    const audioFilters = [];
-    if (options.audioNormalization) {
-        audioFilters.push('dynaudnorm');
-    }
-    if (fadeDuration > 0) {
-        audioFilters.push(`afade=t=in:st=0:d=${fadeDuration}`);
-        audioFilters.push(`afade=t=out:d=${fadeDuration}`);
-    }
-    if (crossfadeDuration > 0) {
-        audioFilters.push(`acrossfade=d=${crossfadeDuration}`);
-    }
-    const presetFilters = EQUALIZER_PRESET_FILTERS[eqPreset] ?? [];
-    if (presetFilters.length > 0) {
-        audioFilters.push(...presetFilters);
-    }
-    const mpvArgs = [
-        '--no-video',
-        '--no-terminal',
-        `--volume=${options.volume}`,
-        '--no-audio-display',
-        '--really-quiet',
-        '--msg-level=all=error',
-        `--input-ipc-server=${ipcPath}`,
-        '--idle=yes',
-        '--cache=yes',
-        '--cache-secs=30',
-        '--network-timeout=10',
-        `--gapless-audio=${gapless ? 'yes' : 'no'}`,
-    ];
-    if (audioFilters.length > 0) {
-        mpvArgs.push(`--af=${audioFilters.join(',')}`);
-    }
-    if (options.proxy) {
-        mpvArgs.push(`--http-proxy=${options.proxy}`);
-    }
-    mpvArgs.push(url);
-    return mpvArgs;
-}
-const EQUALIZER_PRESET_FILTERS = {
-    flat: [],
-    bass_boost: ['equalizer=f=60:width_type=o:width=2:g=5'],
-    vocal: ['equalizer=f=2500:width_type=o:width=2:g=3'],
-    bright: [
-        'equalizer=f=4000:width_type=o:width=2:g=3',
-        'equalizer=f=8000:width_type=o:width=2:g=2',
-    ],
-    warm: [
-        'equalizer=f=100:width_type=o:width=2:g=4',
-        'equalizer=f=250:width_type=o:width=2:g=2',
-    ],
-};
-class PlayerService {
-    static instance;
-    mpvProcess = null;
-    ipcSocket = null;
-    ipcPath = null;
-    currentUrl = null;
-    currentVolume = 70;
-    isPlaying = false;
-    eventCallback = null;
-    ipcConnectRetries = 0;
-    maxIpcRetries = 10;
-    currentTrackId = null; // Track currently playing
-    playSessionId = 0; // Incremented per play() call for unique IPC paths
-    constructor() { }
-    static getInstance() {
-        if (!PlayerService.instance) {
-            PlayerService.instance = new PlayerService();
-        }
-        return PlayerService.instance;
-    }
-    getCurrentTrackId() {
-        return this.currentTrackId;
-    }
-    /**
-     * Register callback for player events (time position, duration updates)
-     */
-    onEvent(callback) {
-        this.eventCallback = callback;
-    }
-    /**
-     * Generate IPC socket path based on platform, unique per play session
-     */
-    getIpcPath() {
-        if (process.platform === 'win32') {
-            // Windows named pipe
-            return `\\\\.\\pipe\\mpvsocket-${process.pid}-${this.playSessionId}`;
-        }
-        else {
-            // Unix domain socket
-            return `/tmp/mpvsocket-${process.pid}-${this.playSessionId}`;
-        }
-    }
-    getMpvCommand() {
-        const configuredPath = process.env['MPV_PATH']?.trim();
-        if (configuredPath) {
-            return configuredPath;
-        }
-        return process.platform === 'win32' ? 'mpv.exe' : 'mpv';
-    }
-    /**
-     * Connect to mpv IPC socket
-     */
-    async connectIpc() {
-        if (!this.ipcPath) {
-            throw new Error('IPC path not set');
-        }
-        return new Promise((resolve, reject) => {
-            const attemptConnect = () => {
-                logger.debug('PlayerService', 'Attempting IPC connection', {
-                    path: this.ipcPath,
-                    attempt: this.ipcConnectRetries + 1,
-                });
-                this.ipcSocket = connect(this.ipcPath);
-                this.ipcSocket.on('connect', () => {
-                    logger.info('PlayerService', 'IPC socket connected');
-                    this.ipcConnectRetries = 0;
-                    // Request property observations
-                    this.sendIpcCommand(['observe_property', 1, 'time-pos']);
-                    this.sendIpcCommand(['observe_property', 2, 'duration']);
-                    this.sendIpcCommand(['observe_property', 3, 'pause']);
-                    this.sendIpcCommand(['observe_property', 4, 'eof-reached']);
-                    resolve();
-                });
-                this.ipcSocket.on('data', (data) => {
-                    this.handleIpcMessage(data.toString());
-                });
-                this.ipcSocket.on('error', (err) => {
-                    logger.debug('PlayerService', 'IPC socket error', {
-                        error: err.message,
-                        attempt: this.ipcConnectRetries + 1,
-                    });
-                    if (this.ipcConnectRetries < this.maxIpcRetries) {
-                        this.ipcConnectRetries++;
-                        setTimeout(attemptConnect, 100); // Retry after 100ms
-                    }
-                    else {
-                        reject(new Error(`Failed to connect to IPC socket after ${this.maxIpcRetries} attempts`));
-                    }
-                });
-                this.ipcSocket.on('close', () => {
-                    logger.debug('PlayerService', 'IPC socket closed');
-                    this.ipcSocket = null;
-                });
-            };
-            attemptConnect();
-        });
-    }
-    /**
-     * Send command to mpv via IPC
-     */
-    sendIpcCommand(command) {
-        if (!this.ipcSocket || this.ipcSocket.destroyed) {
-            logger.warn('PlayerService', 'Cannot send IPC command: socket not connected');
-            return;
-        }
-        const message = JSON.stringify({ command }) + '\n';
-        this.ipcSocket.write(message);
-        logger.debug('PlayerService', 'Sent IPC command', {
-            command: command[0],
-        });
-    }
-    /**
-     * Handle IPC message from mpv
-     */
-    handleIpcMessage(data) {
-        const lines = data.trim().split('\n');
-        for (const line of lines) {
-            try {
-                const message = JSON.parse(line);
-                if (message.event === 'property-change') {
-                    this.handlePropertyChange(message);
-                }
-                else if (message.error !== 'success' && message.error) {
-                    logger.warn('PlayerService', 'IPC error response', {
-                        error: message.error,
-                    });
-                }
-            }
-            catch (err) {
-                logger.debug('PlayerService', 'Failed to parse IPC message', {
-                    data: line,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-    }
-    /**
-     * Handle property change events from mpv
-     */
-    handlePropertyChange(message) {
-        if (!this.eventCallback)
-            return;
-        const event = {};
-        switch (message.name) {
-            case 'time-pos':
-                event.timePos = message.data;
-                logger.debug('PlayerService', 'Time position updated', {
-                    timePos: event.timePos,
-                });
-                break;
-            case 'duration':
-                event.duration = message.data;
-                logger.debug('PlayerService', 'Duration updated', {
-                    duration: event.duration,
-                });
-                break;
-            case 'pause':
-                event.paused = message.data;
-                logger.debug('PlayerService', 'Pause state changed', {
-                    paused: event.paused,
-                });
-                break;
-            case 'eof-reached':
-                event.eof = message.data;
-                if (event.eof) {
-                    this.isPlaying = false;
-                    logger.info('PlayerService', 'End of file reached');
-                }
-                break;
-        }
-        this.eventCallback(event);
-    }
-    async play(url, options) {
-        logger.info('PlayerService', 'play() called with mpv', {
-            urlLength: url.length,
-            urlPreview: url.substring(0, 100),
-            volume: options?.volume || this.currentVolume,
-        });
-        // Extract videoId from URL
-        const videoIdMatch = url.match(/[?&]v=([^&]+)/);
-        const videoId = videoIdMatch ? videoIdMatch[1] : null;
-        // Guard: Don't spawn if same track already playing
-        if (this.currentTrackId === videoId && this.mpvProcess && this.isPlaying) {
-            logger.info('PlayerService', 'Same track already playing, skipping spawn', {
-                videoId,
-            });
-            return;
-        }
-        this.currentTrackId = videoId || null;
-        // Stop any existing playback
-        this.stop();
-        this.currentUrl = url;
-        if (options?.volume !== undefined) {
-            this.currentVolume = options.volume;
-        }
-        // Build YouTube URL from videoId if needed
-        let playUrl = url;
-        if (!url.startsWith('http')) {
-            playUrl = `https://www.youtube.com/watch?v=${url}`;
-        }
-        // Increment session ID for a unique IPC socket path per play call
-        this.playSessionId++;
-        // Generate IPC socket path
-        this.ipcPath = this.getIpcPath();
-        return new Promise((resolve, reject) => {
-            try {
-                logger.debug('PlayerService', 'Spawning mpv process with IPC', {
-                    url: playUrl,
-                    volume: this.currentVolume,
-                    ipcPath: this.ipcPath,
-                });
-                const mpvArgs = buildMpvArgs(playUrl, this.ipcPath, {
-                    volume: this.currentVolume,
-                    audioNormalization: options?.audioNormalization,
-                    proxy: options?.proxy,
-                    gaplessPlayback: options?.gaplessPlayback,
-                    crossfadeDuration: options?.crossfadeDuration,
-                    equalizerPreset: options?.equalizerPreset,
-                });
-                // Capture process in local var so stale exit handlers from a killed
-                // process don't overwrite state belonging to a newly-spawned process.
-                const spawnedProcess = spawn(this.getMpvCommand(), mpvArgs, {
-                    detached: true,
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                    windowsHide: true,
-                });
-                this.mpvProcess = spawnedProcess;
-                if (!spawnedProcess.stdout || !spawnedProcess.stderr) {
-                    throw new Error('Failed to create mpv process streams');
-                }
-                this.isPlaying = true;
-                // Connect to IPC socket after a short delay (let mpv start)
-                setTimeout(() => {
-                    void this.connectIpc().catch(error => {
-                        logger.warn('PlayerService', 'Failed to connect IPC', {
-                            error: error.message,
-                        });
-                        // Continue without IPC - basic playback will still work
-                    });
-                }, 200);
-                // Handle stdout (should be minimal with --really-quiet)
-                spawnedProcess.stdout.on('data', (data) => {
-                    logger.debug('PlayerService', 'mpv stdout', {
-                        output: data.toString().trim(),
-                    });
-                });
-                // Handle stderr (errors)
-                spawnedProcess.stderr.on('data', (data) => {
-                    const error = data.toString().trim();
-                    if (error) {
-                        logger.error('PlayerService', 'mpv stderr', { error });
-                    }
-                });
-                // Handle process exit — guard against stale handlers from killed processes
-                spawnedProcess.on('exit', (code, signal) => {
-                    logger.info('PlayerService', 'mpv process exited', {
-                        code,
-                        signal,
-                        wasPlaying: this.isPlaying,
-                    });
-                    // Only update shared state if this is still the active process
-                    if (this.mpvProcess === spawnedProcess) {
-                        this.isPlaying = false;
-                        this.mpvProcess = null;
-                    }
-                    if (code === 0) {
-                        // Normal exit (track finished)
-                        resolve();
-                    }
-                    else if (code !== null && code > 0) {
-                        // Error exit
-                        reject(new Error(`mpv exited with code ${code}`));
-                    }
-                    // If killed by signal, don't reject (user stopped it)
-                });
-                // Handle errors — same guard
-                spawnedProcess.on('error', (error) => {
-                    logger.error('PlayerService', 'mpv process error', {
-                        error: error.message,
-                        stack: error.stack,
-                    });
-                    if (this.mpvProcess === spawnedProcess) {
-                        this.isPlaying = false;
-                        this.mpvProcess = null;
-                    }
-                    if ('code' in error && error.code === 'ENOENT') {
-                        reject(new Error("mpv executable not found. Install mpv and ensure it's in PATH (or set MPV_PATH)."));
-                        return;
-                    }
-                    reject(error);
-                });
-                logger.info('PlayerService', 'mpv process started successfully');
-            }
-            catch (error) {
-                logger.error('PlayerService', 'Exception in play()', {
-                    error: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                });
-                this.isPlaying = false;
-                reject(error);
-            }
-        });
-    }
-    pause() {
-        logger.debug('PlayerService', 'pause() called');
-        this.isPlaying = false;
-        if (this.ipcSocket && !this.ipcSocket.destroyed) {
-            this.sendIpcCommand(['set_property', 'pause', true]);
-        }
-    }
-    resume() {
-        logger.debug('PlayerService', 'resume() called');
-        this.isPlaying = true;
-        if (this.ipcSocket && !this.ipcSocket.destroyed) {
-            this.sendIpcCommand(['set_property', 'pause', false]);
-            // Reapply volume after resume to ensure audio isn't muted
-            if (this.currentVolume !== undefined) {
-                setTimeout(() => {
-                    this.sendIpcCommand(['set_property', 'volume', this.currentVolume]);
-                }, 100);
-            }
-        }
-        else if (!this.isPlaying && this.currentUrl) {
-            void this.play(this.currentUrl, { volume: this.currentVolume });
-        }
-    }
-    stop() {
-        logger.debug('PlayerService', 'stop() called');
-        // Close IPC socket
-        if (this.ipcSocket && !this.ipcSocket.destroyed) {
-            this.ipcSocket.destroy();
-            this.ipcSocket = null;
-        }
-        if (this.mpvProcess) {
-            try {
-                this.mpvProcess.kill('SIGTERM');
-                this.mpvProcess = null;
-                this.isPlaying = false;
-                this.currentTrackId = null; // Clear track ID on stop
-                logger.info('PlayerService', 'mpv process killed');
-            }
-            catch (error) {
-                logger.error('PlayerService', 'Error killing mpv process', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        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,
-        };
-        if (this.mpvProcess) {
-            // Close piped stdio handles so Node has no open references that could
-            // prevent clean exit or send SIGHUP to the detached mpv process.
-            this.mpvProcess.stdout?.destroy();
-            this.mpvProcess.stderr?.destroy();
-            // Allow detached mpv process to survive after CLI exits.
-            this.mpvProcess.unref();
-        }
-        // 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, options) {
-        logger.info('PlayerService', 'Reattaching to player', { ipcPath });
-        this.ipcPath = ipcPath;
-        await this.connectIpc();
-        this.isPlaying = true;
-        if (options?.trackId)
-            this.currentTrackId = options.trackId;
-        if (options?.currentUrl)
-            this.currentUrl = options.currentUrl;
-        logger.info('PlayerService', 'Successfully reattached to player');
-    }
-    setVolume(volume) {
-        logger.debug('PlayerService', 'setVolume() called', {
-            oldVolume: this.currentVolume,
-            newVolume: volume,
-        });
-        this.currentVolume = Math.max(0, Math.min(100, volume));
-        // Update mpv volume via IPC if connected
-        if (this.ipcSocket && !this.ipcSocket.destroyed) {
-            this.sendIpcCommand(['set_property', 'volume', this.currentVolume]);
-        }
-    }
-    getVolume() {
-        return this.currentVolume;
-    }
-    setSpeed(speed) {
-        const clamped = Math.max(0.25, Math.min(4.0, speed));
-        logger.debug('PlayerService', 'setSpeed() called', { speed: clamped });
-        if (this.ipcSocket && !this.ipcSocket.destroyed) {
-            this.sendIpcCommand(['set_property', 'speed', clamped]);
-        }
-    }
-    isCurrentlyPlaying() {
-        return this.isPlaying;
-    }
-}
-export const getPlayerService = () => PlayerService.getInstance();