@involvex/youtube-music-cli 0.0.47 → 0.0.48

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

@@ -1,292 +0,0 @@
-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',
-            'autoplay',
-            '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) {
-        const now = Date.now();
-        // Compute delta against OLD prevState BEFORE updating it
-        const delta = this.computeDelta(state);
-        this.prevState = { ...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.js

@@ -1,267 +0,0 @@
-// WebSocket server for web UI
-import { createServer as createHttpServer, } from 'node:http';
-import { WebSocketServer, WebSocket } from 'ws';
-import { getWebStreamingService } from "./web-streaming.service.js";
-import { getStaticFileService } from "./static-file.service.js";
-import { logger } from "../logger/logger.service.js";
-class WebSocketServerClass {
-    httpServer = null;
-    wsServer = null;
-    config;
-    streamingService = getWebStreamingService();
-    staticFileService = getStaticFileService();
-    onCommand;
-    onImportRequest;
-    onSearchRequest;
-    onConfigUpdate;
-    constructor() {
-        this.config = {
-            enabled: false,
-            host: 'localhost',
-            port: 8080,
-            enableCors: true,
-            allowedOrigins: ['*'],
-            auth: { enabled: false },
-        };
-    }
-    /**
-     * Start the WebSocket server
-     */
-    async start(options) {
-        this.config = options.config;
-        this.onCommand = options.onCommand;
-        this.onImportRequest = options.onImportRequest;
-        this.onSearchRequest = options.onSearchRequest;
-        this.onConfigUpdate = options.onConfigUpdate;
-        logger.info('WebSocketServer', 'Starting server', {
-            host: this.config.host,
-            port: this.config.port,
-            auth: this.config.auth.enabled,
-        });
-        // Create HTTP server
-        this.httpServer = createHttpServer((req, res) => {
-            this.handleHttpRequest(req, res);
-        });
-        // Create WebSocket server
-        this.wsServer = new WebSocketServer({
-            server: this.httpServer,
-            path: '/ws',
-        });
-        // Handle WebSocket connections
-        this.wsServer.on('connection', (ws, req) => {
-            this.handleWebSocketConnection(ws, req);
-        });
-        // Handle HTTP server errors
-        this.httpServer.on('error', error => {
-            logger.error('WebSocketServer', 'HTTP server error', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-        // Handle WebSocket server errors
-        this.wsServer.on('error', error => {
-            logger.error('WebSocketServer', 'WebSocket server error', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-        // Start listening
-        return new Promise((resolve, reject) => {
-            this.httpServer.listen({
-                host: this.config.host,
-                port: this.config.port,
-            }, () => {
-                logger.info('WebSocketServer', 'Server started', {
-                    url: `http://${this.config.host}:${this.config.port}`,
-                });
-                resolve();
-            });
-            this.httpServer.on('error', reject);
-        });
-    }
-    /**
-     * Handle HTTP requests (for static file serving)
-     */
-    handleHttpRequest(req, res) {
-        // Set CORS headers if enabled
-        if (this.config.enableCors) {
-            const origin = req.headers.origin;
-            if (origin &&
-                (this.config.allowedOrigins.includes('*') ||
-                    this.config.allowedOrigins.includes(origin))) {
-                res.setHeader('Access-Control-Allow-Origin', origin);
-                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-            }
-        }
-        // Handle preflight requests
-        if (req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        // Serve static files
-        const url = req.url ?? '/';
-        this.staticFileService.serve(url, req, res);
-    }
-    /**
-     * Handle WebSocket connection
-     */
-    handleWebSocketConnection(ws, req) {
-        const clientId = this.generateClientId();
-        logger.info('WebSocketServer', 'New connection', {
-            clientId,
-            ip: req.socket.remoteAddress,
-        });
-        // Handle authentication if enabled
-        if (this.config.auth.enabled) {
-            const token = this.extractAuthToken(req);
-            if (!token || token !== this.config.auth.token) {
-                logger.warn('WebSocketServer', 'Authentication failed', { clientId });
-                ws.close(1008, 'Authentication failed');
-                return;
-            }
-        }
-        // Add client to streaming service
-        this.streamingService.addClient(clientId, ws, true);
-        // Send welcome message
-        this.sendToClient(ws, {
-            type: 'auth',
-            success: true,
-            message: 'Connected to YouTube Music CLI',
-        });
-        // Handle incoming messages
-        ws.on('message', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                this.streamingService.handleClientMessage(clientId, message);
-                this.handleClientCommand(clientId, message);
-            }
-            catch (error) {
-                logger.error('WebSocketServer', 'Failed to parse message', {
-                    clientId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-        // Handle close
-        ws.on('close', () => {
-            this.streamingService.removeClient(clientId);
-        });
-        // Handle errors
-        ws.on('error', error => {
-            logger.error('WebSocketServer', 'WebSocket error', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-    }
-    /**
-     * Handle commands from clients
-     */
-    handleClientCommand(_clientId, message) {
-        switch (message.type) {
-            case 'command':
-                if (this.onCommand) {
-                    this.onCommand(message.action);
-                }
-                break;
-            case 'import-request':
-                if (this.onImportRequest) {
-                    this.onImportRequest(message.source, message.url, message.name);
-                }
-                break;
-            case 'search-request':
-                if (this.onSearchRequest) {
-                    this.onSearchRequest(message.query, message.searchType);
-                }
-                break;
-            case 'config-update':
-                if (this.onConfigUpdate) {
-                    this.onConfigUpdate(message.config);
-                }
-                break;
-            case 'auth-request':
-                // Already handled in connection phase
-                break;
-        }
-    }
-    /**
-     * Send message to a specific WebSocket client
-     */
-    sendToClient(ws, message) {
-        if (ws.readyState === WebSocket.OPEN) {
-            try {
-                ws.send(JSON.stringify(message));
-            }
-            catch (error) {
-                logger.error('WebSocketServer', 'Failed to send message', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-    }
-    /**
-     * Generate a unique client ID
-     */
-    generateClientId() {
-        return `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-    /**
-     * Extract auth token from request
-     */
-    extractAuthToken(req) {
-        // Check Authorization header
-        const authHeader = req.headers.authorization;
-        if (authHeader?.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        // Check query parameter
-        const url = req.url ?? '';
-        const urlObj = new URL(url, `http://${req.headers.host}`);
-        return urlObj.searchParams.get('token');
-    }
-    /**
-     * Stop the server
-     */
-    async stop() {
-        logger.info('WebSocketServer', 'Stopping server');
-        // Disconnect all clients
-        this.streamingService.disconnectAll();
-        // Close WebSocket server
-        if (this.wsServer) {
-            this.wsServer.close();
-            this.wsServer = null;
-        }
-        // Close HTTP server
-        if (this.httpServer) {
-            return new Promise(resolve => {
-                this.httpServer.close(() => {
-                    this.httpServer = null;
-                    logger.info('WebSocketServer', 'Server stopped');
-                    resolve();
-                });
-            });
-        }
-    }
-    /**
-     * Check if server is running
-     */
-    isRunning() {
-        return this.httpServer !== null;
-    }
-    /**
-     * Get server URL
-     */
-    getServerUrl() {
-        if (!this.isRunning()) {
-            throw new Error('Server is not running');
-        }
-        return `http://${this.config.host}:${this.config.port}`;
-    }
-}
-// Singleton instance
-let webSocketServerInstance = null;
-export function getWebSocketServer() {
-    if (!webSocketServerInstance) {
-        webSocketServerInstance = new WebSocketServerClass();
-    }
-    return webSocketServerInstance;
-}