@involvex/youtube-music-cli 0.0.18 → 0.0.19

package/dist/source/services/web/web-server-manager.js

@@ -0,0 +1,219 @@
+import { getWebSocketServer } from "./websocket.server.js";
+import { getWebStreamingService } from "./web-streaming.service.js";
+import { getConfigService } from "../config/config.service.js";
+import { getImportService } from "../import/import.service.js";
+import { logger } from "../logger/logger.service.js";
+class WebServerManager {
+    config;
+    isRunning = false;
+    cleanupHooks = [];
+    constructor() {
+        // Load config or use defaults
+        const configService = getConfigService();
+        const savedConfig = configService.get('webServer');
+        this.config = savedConfig ?? {
+            enabled: false,
+            host: 'localhost',
+            port: 8080,
+            enableCors: true,
+            allowedOrigins: ['*'],
+            auth: { enabled: false },
+        };
+        // Save default config if not present
+        if (!savedConfig) {
+            configService.set('webServer', this.config);
+        }
+    }
+    /**
+     * Start the web server
+     */
+    async start(options) {
+        if (this.isRunning) {
+            logger.warn('WebServerManager', 'Server already running');
+            return;
+        }
+        // Apply CLI options
+        const finalConfig = { ...this.config };
+        if (options) {
+            if (options.host !== undefined) {
+                finalConfig.host = options.host;
+            }
+            if (options.port !== undefined) {
+                finalConfig.port = options.port;
+            }
+            if (options.auth !== undefined) {
+                finalConfig.auth.enabled = true;
+                finalConfig.auth.token = options.auth;
+            }
+        }
+        logger.info('WebServerManager', 'Starting web server', finalConfig);
+        try {
+            const wsServer = getWebSocketServer();
+            // Set up command handler
+            const cleanupCommand = this.setupCommandHandler();
+            this.cleanupHooks.push(cleanupCommand);
+            // Set up import handler
+            const cleanupImport = this.setupImportHandler();
+            this.cleanupHooks.push(cleanupImport);
+            // Start the server
+            await wsServer.start({
+                config: finalConfig,
+                onCommand: this.handleCommand.bind(this),
+                onImportRequest: this.handleImportRequest.bind(this),
+            });
+            this.isRunning = true;
+            // Set up graceful shutdown
+            this.setupShutdownHooks();
+        }
+        catch (error) {
+            logger.error('WebServerManager', 'Failed to start server', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Stop the web server
+     */
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        logger.info('WebServerManager', 'Stopping web server');
+        // Clean up hooks
+        for (const cleanup of this.cleanupHooks) {
+            cleanup();
+        }
+        this.cleanupHooks = [];
+        // Stop the WebSocket server
+        const wsServer = getWebSocketServer();
+        await wsServer.stop();
+        this.isRunning = false;
+    }
+    /**
+     * Set up player command handler
+     */
+    setupCommandHandler() {
+        const streamingService = getWebStreamingService();
+        const unsubscribe = streamingService.onMessage(message => {
+            if (message.type === 'command') {
+                this.handleCommand(message.action);
+            }
+        });
+        return unsubscribe;
+    }
+    /**
+     * Set up import progress handler
+     */
+    setupImportHandler() {
+        const importService = getImportService();
+        const streamingService = getWebStreamingService();
+        const unsubscribe = importService.onProgress(progress => {
+            streamingService.onImportProgress(progress);
+        });
+        return unsubscribe;
+    }
+    /**
+     * Handle command from web client
+     */
+    handleCommand(action) {
+        // This will be handled by the player store
+        logger.debug('WebServerManager', 'Received command from client', { action });
+    }
+    /**
+     * Handle import request from web client
+     */
+    async handleImportRequest(source, url, name) {
+        logger.info('WebServerManager', 'Import request from client', {
+            source,
+            url,
+            name,
+        });
+        try {
+            const importService = getImportService();
+            await importService.importPlaylist(source, url, name);
+        }
+        catch (error) {
+            logger.error('WebServerManager', 'Import failed', {
+                source,
+                url,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Update player state (call this when player state changes)
+     */
+    updateState(state) {
+        if (!this.isRunning)
+            return;
+        const streamingService = getWebStreamingService();
+        streamingService.onStateChange(state);
+    }
+    /**
+     * Set up graceful shutdown hooks
+     */
+    setupShutdownHooks() {
+        const shutdown = async () => {
+            await this.stop();
+        };
+        process.on('beforeExit', shutdown);
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        this.cleanupHooks.push(() => {
+            process.off('beforeExit', shutdown);
+            process.off('SIGINT', shutdown);
+            process.off('SIGTERM', shutdown);
+        });
+    }
+    /**
+     * Check if server is running
+     */
+    isServerRunning() {
+        return this.isRunning;
+    }
+    /**
+     * Get server URL
+     */
+    getServerUrl() {
+        const wsServer = getWebSocketServer();
+        return wsServer.getServerUrl();
+    }
+    /**
+     * Get server statistics
+     */
+    getStats() {
+        if (!this.isRunning) {
+            return { running: false };
+        }
+        const streamingService = getWebStreamingService();
+        const stats = streamingService.getStats();
+        return {
+            running: true,
+            url: this.getServerUrl(),
+            clients: stats.clients,
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        const configService = getConfigService();
+        configService.set('webServer', this.config);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+// Singleton instance
+let webServerManagerInstance = null;
+export function getWebServerManager() {
+    if (!webServerManagerInstance) {
+        webServerManagerInstance = new WebServerManager();
+    }
+    return webServerManagerInstance;
+}

package/dist/source/services/web/web-streaming.service.d.ts

@@ -0,0 +1,88 @@
+import type { PlayerState } from '../../types/player.types.ts';
+import type { ServerMessage, ClientMessage } from '../../types/web.types.ts';
+import type { ImportProgress, ImportResult } from '../../types/import.types.ts';
+type MessageHandler = (message: ClientMessage) => void;
+declare class WebStreamingService {
+    private clients;
+    private clientInfo;
+    private messageHandlers;
+    private prevState;
+    private readonly UPDATE_THROTTLE_MS;
+    private lastUpdateTime;
+    private pendingUpdate;
+    private updateTimer;
+    /**
+     * Add a client connection
+     */
+    addClient(clientId: string, ws: WebSocket, authenticated?: boolean): void;
+    /**
+     * Remove a client connection
+     */
+    removeClient(clientId: string): void;
+    /**
+     * Check if a client exists
+     */
+    hasClient(clientId: string): boolean;
+    /**
+     * Get client count
+     */
+    getClientCount(): number;
+    /**
+     * Get all connected clients
+     */
+    getClients(): string[];
+    /**
+     * Handle incoming message from a client
+     */
+    handleClientMessage(clientId: string, message: unknown): void;
+    /**
+     * Register a handler for incoming client messages
+     */
+    onMessage(handler: MessageHandler): () => void;
+    /**
+     * Send a message to a specific client
+     */
+    private sendToClient;
+    /**
+     * Broadcast a message to all connected clients
+     */
+    broadcast(message: ServerMessage): void;
+    /**
+     * Compute partial state delta (only changed fields)
+     */
+    private computeDelta;
+    /**
+     * Update and broadcast player state (throttled)
+     */
+    onStateChange(state: PlayerState): void;
+    /**
+     * Send pending state update to all clients
+     */
+    private sendPendingUpdate;
+    /**
+     * Broadcast import progress
+     */
+    onImportProgress(progress: ImportProgress): void;
+    /**
+     * Broadcast import result
+     */
+    onImportResult(result: ImportResult): void;
+    /**
+     * Broadcast error message
+     */
+    sendError(error: string, code?: string): void;
+    /**
+     * Disconnect all clients
+     */
+    disconnectAll(): void;
+    /**
+     * Get server statistics
+     */
+    getStats(): {
+        clients: number;
+        totalConnections: number;
+        uptime: number;
+    };
+}
+export declare function getWebStreamingService(): WebStreamingService;
+export {};

package/dist/source/services/web/web-streaming.service.js

@@ -0,0 +1,290 @@
+import { logger } from "../logger/logger.service.js";
+class WebStreamingService {
+    clients = new Map();
+    clientInfo = new Map();
+    messageHandlers = new Set();
+    prevState = null;
+    UPDATE_THROTTLE_MS = 250; // Throttle updates to 4/sec
+    lastUpdateTime = 0;
+    pendingUpdate = null;
+    updateTimer = null;
+    /**
+     * Add a client connection
+     */
+    addClient(clientId, ws, authenticated = true) {
+        this.clients.set(clientId, ws);
+        this.clientInfo.set(clientId, {
+            id: clientId,
+            authenticated,
+            connectedAt: Date.now(),
+            lastHeartbeat: Date.now(),
+        });
+        logger.info('WebStreamingService', 'Client connected', {
+            clientId,
+            authenticated,
+        });
+        // Send initial state if available
+        if (this.prevState) {
+            this.sendToClient(clientId, {
+                type: 'state-update',
+                state: this.prevState,
+            });
+        }
+        // Send connection event
+        this.broadcast({
+            type: 'event',
+            event: 'client-connected',
+            data: { clientId, clientCount: this.clients.size },
+        });
+    }
+    /**
+     * Remove a client connection
+     */
+    removeClient(clientId) {
+        const hadClient = this.clients.has(clientId);
+        this.clients.delete(clientId);
+        this.clientInfo.delete(clientId);
+        if (hadClient) {
+            logger.info('WebStreamingService', 'Client disconnected', {
+                clientId,
+                remainingClients: this.clients.size,
+            });
+            this.broadcast({
+                type: 'event',
+                event: 'client-disconnected',
+                data: { clientId, clientCount: this.clients.size },
+            });
+        }
+    }
+    /**
+     * Check if a client exists
+     */
+    hasClient(clientId) {
+        return this.clients.has(clientId);
+    }
+    /**
+     * Get client count
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Get all connected clients
+     */
+    getClients() {
+        return Array.from(this.clients.keys());
+    }
+    /**
+     * Handle incoming message from a client
+     */
+    handleClientMessage(clientId, message) {
+        try {
+            const msg = message;
+            // Update client heartbeat
+            const info = this.clientInfo.get(clientId);
+            if (info) {
+                info.lastHeartbeat = Date.now();
+                this.clientInfo.set(clientId, info);
+            }
+            // Emit to all handlers
+            for (const handler of this.messageHandlers) {
+                handler(msg);
+            }
+        }
+        catch (error) {
+            logger.error('WebStreamingService', 'Failed to handle client message', {
+                clientId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Register a handler for incoming client messages
+     */
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return () => {
+            this.messageHandlers.delete(handler);
+        };
+    }
+    /**
+     * Send a message to a specific client
+     */
+    sendToClient(clientId, message) {
+        const ws = this.clients.get(clientId);
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        try {
+            ws.send(JSON.stringify(message));
+        }
+        catch (error) {
+            logger.error('WebStreamingService', 'Failed to send to client', {
+                clientId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Broadcast a message to all connected clients
+     */
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        for (const [clientId, ws] of this.clients) {
+            if (ws.readyState === WebSocket.OPEN) {
+                try {
+                    ws.send(data);
+                }
+                catch (error) {
+                    logger.error('WebStreamingService', 'Failed to broadcast to client', {
+                        clientId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Compute partial state delta (only changed fields)
+     */
+    computeDelta(newState) {
+        if (!this.prevState) {
+            return newState;
+        }
+        const delta = {};
+        // Check each field for changes
+        const fields = [
+            'currentTrack',
+            'isPlaying',
+            'volume',
+            'speed',
+            'progress',
+            'duration',
+            'queue',
+            'queuePosition',
+            'repeat',
+            'shuffle',
+            'isLoading',
+            'error',
+        ];
+        for (const field of fields) {
+            const prevValue = this.prevState[field];
+            const newValue = newState[field];
+            // Deep comparison for objects/arrays
+            if (typeof prevValue === 'object' && prevValue !== null) {
+                if (JSON.stringify(prevValue) !== JSON.stringify(newValue)) {
+                    delta[field] = newValue;
+                }
+            }
+            else if (prevValue !== newValue) {
+                delta[field] = newValue;
+            }
+        }
+        return delta;
+    }
+    /**
+     * Update and broadcast player state (throttled)
+     */
+    onStateChange(state) {
+        this.prevState = { ...state };
+        const now = Date.now();
+        const delta = this.computeDelta(state);
+        // Skip if no changes
+        if (Object.keys(delta).length === 0) {
+            return;
+        }
+        // Merge with pending update
+        this.pendingUpdate = { ...(this.pendingUpdate || {}), ...delta };
+        // Clear existing timer
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
+        }
+        // If throttle period passed, send immediately
+        if (now - this.lastUpdateTime >= this.UPDATE_THROTTLE_MS) {
+            this.sendPendingUpdate();
+        }
+        else {
+            // Otherwise, schedule update
+            this.updateTimer = setTimeout(() => {
+                this.sendPendingUpdate();
+            }, this.UPDATE_THROTTLE_MS - (now - this.lastUpdateTime));
+        }
+    }
+    /**
+     * Send pending state update to all clients
+     */
+    sendPendingUpdate() {
+        if (!this.pendingUpdate)
+            return;
+        this.broadcast({
+            type: 'state-update',
+            state: this.pendingUpdate,
+        });
+        this.pendingUpdate = null;
+        this.lastUpdateTime = Date.now();
+    }
+    /**
+     * Broadcast import progress
+     */
+    onImportProgress(progress) {
+        this.broadcast({
+            type: 'import-progress',
+            data: progress,
+        });
+    }
+    /**
+     * Broadcast import result
+     */
+    onImportResult(result) {
+        this.broadcast({
+            type: 'import-result',
+            data: result,
+        });
+    }
+    /**
+     * Broadcast error message
+     */
+    sendError(error, code) {
+        this.broadcast({
+            type: 'error',
+            error,
+            code,
+        });
+    }
+    /**
+     * Disconnect all clients
+     */
+    disconnectAll() {
+        for (const [, ws] of this.clients) {
+            try {
+                ws.close();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.clients.clear();
+        this.clientInfo.clear();
+        logger.info('WebStreamingService', 'All clients disconnected');
+    }
+    /**
+     * Get server statistics
+     */
+    getStats() {
+        const now = Date.now();
+        const oldestClient = Array.from(this.clientInfo.values()).sort((a, b) => a.connectedAt - b.connectedAt)[0];
+        return {
+            clients: this.clients.size,
+            totalConnections: this.clientInfo.size,
+            uptime: oldestClient ? now - oldestClient.connectedAt : 0,
+        };
+    }
+}
+// Singleton instance
+let webStreamingServiceInstance = null;
+export function getWebStreamingService() {
+    if (!webStreamingServiceInstance) {
+        webStreamingServiceInstance = new WebStreamingService();
+    }
+    return webStreamingServiceInstance;
+}

package/dist/source/services/web/websocket.server.d.ts

@@ -0,0 +1,58 @@
+import type { WebServerConfig } from '../../types/web.types.ts';
+interface WebSocketServerOptions {
+    config: WebServerConfig;
+    onCommand?: (action: unknown) => void;
+    onImportRequest?: (source: 'spotify' | 'youtube', url: string, name?: string) => void;
+}
+declare class WebSocketServerClass {
+    private httpServer;
+    private wsServer;
+    private config;
+    private streamingService;
+    private staticFileService;
+    private onCommand?;
+    private onImportRequest?;
+    constructor();
+    /**
+     * Start the WebSocket server
+     */
+    start(options: WebSocketServerOptions): Promise<void>;
+    /**
+     * Handle HTTP requests (for static file serving)
+     */
+    private handleHttpRequest;
+    /**
+     * Handle WebSocket connection
+     */
+    private handleWebSocketConnection;
+    /**
+     * Handle commands from clients
+     */
+    private handleClientCommand;
+    /**
+     * Send message to a specific WebSocket client
+     */
+    private sendToClient;
+    /**
+     * Generate a unique client ID
+     */
+    private generateClientId;
+    /**
+     * Extract auth token from request
+     */
+    private extractAuthToken;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get server URL
+     */
+    getServerUrl(): string;
+}
+export declare function getWebSocketServer(): WebSocketServerClass;
+export {};