@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,125 @@
+// Configuration management service
+import { CONFIG_DIR, CONFIG_FILE } from "../../utils/constants.js";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { BUILTIN_THEMES, DEFAULT_THEME } from "../../config/themes.config.js";
+class ConfigService {
+    configPath;
+    configDir;
+    config;
+    constructor() {
+        this.configDir = CONFIG_DIR;
+        this.configPath = CONFIG_FILE;
+        this.config = this.load() || this.getDefaultConfig();
+    }
+    getDefaultConfig() {
+        return {
+            theme: 'dark',
+            volume: 70,
+            keybindings: {},
+            playlists: [],
+            history: [],
+            favorites: [],
+            repeat: 'off',
+            shuffle: false,
+            customTheme: undefined,
+            streamQuality: 'high',
+        };
+    }
+    load() {
+        try {
+            if (!existsSync(this.configPath)) {
+                return null;
+            }
+            const data = readFileSync(this.configPath, 'utf-8');
+            const config = JSON.parse(data);
+            // Merge with defaults to handle new fields
+            return { ...this.getDefaultConfig(), ...config };
+        }
+        catch {
+            return null;
+        }
+    }
+    save() {
+        try {
+            // Ensure config directory exists
+            if (!existsSync(this.configDir)) {
+                mkdirSync(this.configDir, { recursive: true });
+            }
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save config:', error);
+        }
+    }
+    get(key) {
+        return this.config[key];
+    }
+    set(key, value) {
+        this.config[key] = value;
+        this.save();
+    }
+    updateTheme(themeName) {
+        this.config.theme = themeName;
+        this.save();
+    }
+    getTheme() {
+        if (this.config.theme === 'custom' && this.config.customTheme) {
+            return this.config.customTheme;
+        }
+        const builtinTheme = BUILTIN_THEMES[this.config.theme];
+        if (builtinTheme) {
+            return builtinTheme;
+        }
+        return DEFAULT_THEME;
+    }
+    setCustomTheme(theme) {
+        this.config.customTheme = theme;
+        this.config.theme = 'custom';
+        this.save();
+    }
+    getKeybinding(action) {
+        return this.config.keybindings[action]?.keys;
+    }
+    setKeybinding(action, keys) {
+        this.config.keybindings[action] = {
+            keys,
+            description: `Custom binding for ${action}`,
+        };
+        this.save();
+    }
+    addToHistory(trackId) {
+        // Add to front of history, limit to 1000
+        this.config.history = [
+            trackId,
+            ...this.config.history.filter(id => id !== trackId),
+        ].slice(0, 1000);
+        this.save();
+    }
+    getHistory() {
+        return this.config.history;
+    }
+    addFavorite(trackId) {
+        if (!this.config.favorites.includes(trackId)) {
+            this.config.favorites.push(trackId);
+            this.save();
+        }
+    }
+    removeFavorite(trackId) {
+        this.config.favorites = this.config.favorites.filter(id => id !== trackId);
+        this.save();
+    }
+    isFavorite(trackId) {
+        return this.config.favorites.includes(trackId);
+    }
+    getFavorites() {
+        return this.config.favorites;
+    }
+}
+// Singleton instance
+let configServiceInstance = null;
+export function getConfigService() {
+    if (!configServiceInstance) {
+        configServiceInstance = new ConfigService();
+    }
+    return configServiceInstance;
+}

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

@@ -0,0 +1,10 @@
+declare class Logger {
+    private writeToFile;
+    debug(category: string, message: string, data?: unknown): void;
+    info(category: string, message: string, data?: unknown): void;
+    warn(category: string, message: string, data?: unknown): void;
+    error(category: string, message: string, data?: unknown): void;
+    getLogPath(): string;
+}
+export declare const logger: Logger;
+export {};

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

@@ -0,0 +1,52 @@
+// Debug logging service
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const DEBUG_DIR = path.join(os.homedir(), '.youtube-music-cli');
+const DEBUG_FILE = path.join(DEBUG_DIR, 'debug.log');
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB
+// Ensure debug directory exists
+if (!fs.existsSync(DEBUG_DIR)) {
+    fs.mkdirSync(DEBUG_DIR, { recursive: true });
+}
+// Rotate log if too large
+if (fs.existsSync(DEBUG_FILE)) {
+    const stats = fs.statSync(DEBUG_FILE);
+    if (stats.size > MAX_LOG_SIZE) {
+        const backupFile = path.join(DEBUG_DIR, 'debug.log.old');
+        if (fs.existsSync(backupFile)) {
+            fs.unlinkSync(backupFile);
+        }
+        fs.renameSync(DEBUG_FILE, backupFile);
+    }
+}
+class Logger {
+    writeToFile(level, category, message, data) {
+        const timestamp = new Date().toISOString();
+        const dataStr = data ? `\n${JSON.stringify(data, null, 2)}` : '';
+        const logLine = `[${timestamp}] [${level}] [${category}] ${message}${dataStr}\n`;
+        fs.appendFileSync(DEBUG_FILE, logLine);
+    }
+    debug(category, message, data) {
+        this.writeToFile('DEBUG', category, message, data);
+    }
+    info(category, message, data) {
+        this.writeToFile('INFO', category, message, data);
+        // Disabled: console.log causes Ink to re-render constantly
+        // console.log(`[${category}] ${message}`);
+    }
+    warn(category, message, data) {
+        this.writeToFile('WARN', category, message, data);
+        // Disabled: console.warn causes Ink to re-render
+        // console.warn(`[${category}] ${message}`);
+    }
+    error(category, message, data) {
+        this.writeToFile('ERROR', category, message, data);
+        // Keep console.error for critical errors, but this should be rare
+        console.error(`[${category}] ${message}`);
+    }
+    getLogPath() {
+        return DEBUG_FILE;
+    }
+}
+export const logger = new Logger();

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

@@ -0,0 +1,58 @@
+export type PlayOptions = {
+    volume?: number;
+};
+export type PlayerEventCallback = (event: {
+    timePos?: number;
+    duration?: number;
+    paused?: boolean;
+    eof?: boolean;
+}) => void;
+declare class PlayerService {
+    private static instance;
+    private mpvProcess;
+    private ipcSocket;
+    private ipcPath;
+    private currentUrl;
+    private currentVolume;
+    private isPlaying;
+    private eventCallback;
+    private ipcConnectRetries;
+    private readonly maxIpcRetries;
+    private currentTrackId;
+    private constructor();
+    static getInstance(): PlayerService;
+    getCurrentTrackId(): string | null;
+    /**
+     * Register callback for player events (time position, duration updates)
+     */
+    onEvent(callback: PlayerEventCallback): void;
+    /**
+     * Generate IPC socket path based on platform
+     */
+    private getIpcPath;
+    /**
+     * Connect to mpv IPC socket
+     */
+    private connectIpc;
+    /**
+     * Send command to mpv via IPC
+     */
+    private sendIpcCommand;
+    /**
+     * Handle IPC message from mpv
+     */
+    private handleIpcMessage;
+    /**
+     * Handle property change events from mpv
+     */
+    private handlePropertyChange;
+    play(url: string, options?: PlayOptions): Promise<void>;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    isCurrentlyPlaying(): boolean;
+}
+export declare const getPlayerService: () => PlayerService;
+export {};

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

@@ -0,0 +1,349 @@
+// 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";
+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
+    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
+     */
+    getIpcPath() {
+        if (process.platform === 'win32') {
+            // Windows named pipe
+            return `\\\\.\\pipe\\mpvsocket-${process.pid}`;
+        }
+        else {
+            // Unix domain socket
+            return `/tmp/mpvsocket-${process.pid}`;
+        }
+    }
+    /**
+     * 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) {
+                    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}`;
+        }
+        // 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,
+                });
+                // Spawn mpv with JSON IPC for better control
+                this.mpvProcess = spawn('mpv', [
+                    '--no-video', // Audio only
+                    '--no-terminal', // Don't read from stdin
+                    `--volume=${this.currentVolume}`,
+                    '--no-audio-display', // Don't show album art in terminal
+                    '--really-quiet', // Minimal output
+                    '--msg-level=all=error', // Only show errors
+                    `--input-ipc-server=${this.ipcPath}`, // Enable IPC
+                    '--idle=yes', // Keep mpv running after playback ends
+                    playUrl,
+                ]);
+                if (!this.mpvProcess.stdout || !this.mpvProcess.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)
+                this.mpvProcess.stdout.on('data', (data) => {
+                    logger.debug('PlayerService', 'mpv stdout', {
+                        output: data.toString().trim(),
+                    });
+                });
+                // Handle stderr (errors)
+                this.mpvProcess.stderr.on('data', (data) => {
+                    const error = data.toString().trim();
+                    if (error) {
+                        logger.error('PlayerService', 'mpv stderr', { error });
+                    }
+                });
+                // Handle process exit
+                this.mpvProcess.on('exit', (code, signal) => {
+                    logger.info('PlayerService', 'mpv process exited', {
+                        code,
+                        signal,
+                        wasPlaying: this.isPlaying,
+                    });
+                    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
+                this.mpvProcess.on('error', (error) => {
+                    logger.error('PlayerService', 'mpv process error', {
+                        error: error.message,
+                        stack: error.stack,
+                    });
+                    this.isPlaying = false;
+                    this.mpvProcess = null;
+                    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;
+    }
+    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;
+    }
+    isCurrentlyPlaying() {
+        return this.isPlaying;
+    }
+}
+export const getPlayerService = () => PlayerService.getInstance();

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

@@ -0,0 +1,24 @@
+import type { Track } from '../../types/youtube-music.types.ts';
+export interface PersistedPlayerState {
+    schemaVersion: number;
+    currentTrack: Track | null;
+    queue: Track[];
+    queuePosition: number;
+    progress: number;
+    volume: number;
+    shuffle: boolean;
+    repeat: 'off' | 'all' | 'one';
+    lastUpdated: string;
+}
+/**
+ * Saves player state to disk
+ */
+export declare function savePlayerState(state: Partial<PersistedPlayerState>): Promise<void>;
+/**
+ * Loads player state from disk
+ */
+export declare function loadPlayerState(): Promise<PersistedPlayerState | null>;
+/**
+ * Clears saved player state
+ */
+export declare function clearPlayerState(): Promise<void>;