@involvex/youtube-music-cli 0.0.18 → 0.0.20

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,63 @@
+import type { WebServerConfig } from '../../types/web.types.ts';
+import type { PlayerAction } from '../../types/player.types.ts';
+interface WebSocketServerOptions {
+    config: WebServerConfig;
+    onCommand?: (action: PlayerAction) => void;
+    onImportRequest?: (source: 'spotify' | 'youtube', url: string, name?: string) => void;
+    onSearchRequest?: (query: string, searchType: 'all' | 'songs' | 'artists' | 'albums' | 'playlists') => void;
+    onConfigUpdate?: (config: Record<string, unknown>) => void;
+}
+declare class WebSocketServerClass {
+    private httpServer;
+    private wsServer;
+    private config;
+    private streamingService;
+    private staticFileService;
+    private onCommand?;
+    private onImportRequest?;
+    private onSearchRequest?;
+    private onConfigUpdate?;
+    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 {};

package/dist/source/services/web/websocket.server.js

@@ -0,0 +1,267 @@
+// 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;
+}

package/dist/source/stores/player.store.js

@@ -8,6 +8,8 @@ import { getNotificationService } from "../services/notification/notification.se
 import { getScrobblingService } from "../services/scrobbling/scrobbling.service.js";
 import { getDiscordRpcService } from "../services/discord/discord-rpc.service.js";
 import { getMprisService } from "../services/mpris/mpris.service.js";
+import { getWebServerManager } from "../services/web/web-server-manager.js";
+import { getWebStreamingService } from "../services/web/web-streaming.service.js";
 const initialState = {
     currentTrack: null,
     isPlaying: false,
@@ -551,6 +553,28 @@ export function PlayerProvider({ children }) {
         // Only register handlers once, update via ref
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
+    // Web streaming: Broadcast state changes to connected clients
+    useEffect(() => {
+        // Initialize web streaming service and set up command handler
+        const streamingService = getWebStreamingService();
+        // Set up handler for incoming commands from web clients
+        const unsubscribe = streamingService.onMessage(message => {
+            if (message.type === 'command') {
+                dispatch(message.action);
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [dispatch]);
+    // Broadcast state changes to web clients
+    useEffect(() => {
+        const webServerManager = getWebServerManager();
+        if (webServerManager.isServerRunning()) {
+            const streamingService = getWebStreamingService();
+            streamingService.onStateChange(state);
+        }
+    }, [state]);
     const actions = useMemo(() => ({
         play: (track) => {
             logger.info('PlayerProvider', 'play() action dispatched', {

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

@@ -11,4 +11,12 @@ export interface Flags {
     showSuggestions?: boolean;
     headless?: boolean;
     action?: 'pause' | 'resume' | 'next' | 'previous';
+    importSource?: 'spotify' | 'youtube';
+    importUrl?: string;
+    importName?: string;
+    web?: boolean;
+    webHost?: string;
+    webPort?: number;
+    webOnly?: boolean;
+    webAuth?: string;
 }

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

@@ -1,5 +1,6 @@
 import type { Playlist } from './youtube-music.types.ts';
 import type { Theme } from './theme.types.ts';
+import type { WebServerConfig } from './web.types.ts';
 export type RepeatMode = 'off' | 'all' | 'one';
 export type DownloadFormat = 'mp3' | 'm4a';
 export interface KeybindingConfig {
@@ -34,4 +35,5 @@ export interface Config {
     downloadsEnabled?: boolean;
     downloadDirectory?: string;
     downloadFormat?: DownloadFormat;
+    webServer?: WebServerConfig;
 }