@involvex/youtube-music-cli 0.0.19 → 0.0.21

package/dist/source/services/version-check/version-check.service.js

@@ -0,0 +1,121 @@
+// Version check service for npm registry updates
+import { APP_NAME, APP_VERSION } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+class VersionCheckService {
+    static instance;
+    NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+    CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+    constructor() { }
+    static getInstance() {
+        if (!VersionCheckService.instance) {
+            VersionCheckService.instance = new VersionCheckService();
+        }
+        return VersionCheckService.instance;
+    }
+    /**
+     * Compare two semantic version strings
+     * Returns: 1 if a > b, -1 if a < b, 0 if equal
+     */
+    compareVersions(a, b) {
+        const parseVersion = (v) => {
+            // Remove 'v' prefix if present and split by non-numeric chars
+            const clean = v.replace(/^v/i, '');
+            return clean.split(/[.-]/).map(part => {
+                const num = parseInt(part, 10);
+                return Number.isNaN(num) ? 0 : num;
+            });
+        };
+        const partsA = parseVersion(a);
+        const partsB = parseVersion(b);
+        const maxLength = Math.max(partsA.length, partsB.length);
+        for (let i = 0; i < maxLength; i++) {
+            const partA = partsA[i] ?? 0;
+            const partB = partsB[i] ?? 0;
+            if (partA > partB)
+                return 1;
+            if (partA < partB)
+                return -1;
+        }
+        return 0;
+    }
+    /**
+     * Check if a version check should be performed (once per 24 hours)
+     */
+    shouldCheck(lastCheck) {
+        if (!lastCheck)
+            return true;
+        try {
+            const lastCheckDate = new Date(lastCheck);
+            const now = new Date();
+            const diff = now.getTime() - lastCheckDate.getTime();
+            return diff >= this.CHECK_INTERVAL;
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Mark that a version check has been performed
+     * Returns the timestamp string to store
+     */
+    markChecked() {
+        return new Date().toISOString();
+    }
+    /**
+     * Check npm registry for available updates
+     */
+    async checkForUpdates(currentVersion = APP_VERSION) {
+        try {
+            logger.debug('VersionCheckService', 'Checking for updates', {
+                package: APP_NAME,
+                currentVersion,
+            });
+            const url = `${this.NPM_REGISTRY_URL}/${APP_NAME}`;
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(5000), // 5 second timeout
+            });
+            if (!response.ok) {
+                logger.warn('VersionCheckService', 'Failed to fetch package info', {
+                    status: response.status,
+                });
+                return {
+                    hasUpdate: false,
+                    currentVersion,
+                    latestVersion: currentVersion,
+                };
+            }
+            const data = (await response.json());
+            const latestVersion = data['dist-tags']?.latest;
+            if (!latestVersion) {
+                logger.warn('VersionCheckService', 'No latest version found in response');
+                return {
+                    hasUpdate: false,
+                    currentVersion,
+                    latestVersion: currentVersion,
+                };
+            }
+            const hasUpdate = this.compareVersions(latestVersion, currentVersion) > 0;
+            logger.info('VersionCheckService', 'Version check complete', {
+                currentVersion,
+                latestVersion,
+                hasUpdate,
+            });
+            return {
+                hasUpdate,
+                currentVersion,
+                latestVersion,
+            };
+        }
+        catch (error) {
+            logger.error('VersionCheckService', 'Error checking for updates', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                hasUpdate: false,
+                currentVersion,
+                latestVersion: currentVersion,
+            };
+        }
+    }
+}
+export const getVersionCheckService = () => VersionCheckService.getInstance();

package/dist/source/services/web/static-file.service.js

@@ -43,11 +43,7 @@ class StaticFileService {
             projectRoot = join(currentDir, '..', '..', '..');
         }
         this.webDistDir = join(projectRoot, 'dist', 'web');
-        console.log('[StaticFileService] Path resolution:', {
-            currentFile,
-            currentDir,
-            isDist,
-            projectRoot,
+        logger.debug('StaticFileService', 'Path resolved', {
             webDistDir: this.webDistDir,
             exists: existsSync(this.webDistDir),
         });
@@ -66,20 +62,13 @@ class StaticFileService {
         if (this.indexHtmlLoaded)
             return;
         const indexPath = join(this.webDistDir, 'index.html');
-        console.log('[StaticFileService] Loading index.html:', {
-            webDistDir: this.webDistDir,
-            indexPath,
-            exists: existsSync(indexPath),
-        });
         try {
             const buffer = await readFile(indexPath);
             this.indexHtml = buffer.toString('utf-8');
             this.indexHtmlLoaded = true;
-            logger.debug('StaticFileService', 'index.html loaded', { indexPath });
-            console.log('[StaticFileService] index.html loaded successfully');
+            logger.info('StaticFileService', 'index.html loaded');
         }
         catch (error) {
-            console.error('[StaticFileService] Failed to load index.html:', error);
             logger.error('StaticFileService', 'Failed to load index.html', {
                 indexPath,
                 error: error instanceof Error ? error.message : String(error),

package/dist/source/services/web/web-server-manager.d.ts

@@ -4,6 +4,7 @@ declare class WebServerManager {
     private config;
     private isRunning;
     private cleanupHooks;
+    private internalState;
     constructor();
     /**
      * Start the web server
@@ -29,10 +30,31 @@ declare class WebServerManager {
      * Handle import request from web client
      */
     private handleImportRequest;
+    /**
+     * Handle search request from web client
+     */
+    private handleSearchRequest;
+    /**
+     * Handle config update from web client
+     */
+    private handleConfigUpdate;
     /**
      * Update player state (call this when player state changes)
+     * This is called by PlayerProvider in normal mode to sync state
      */
     updateState(state: PlayerState): void;
+    /**
+     * Broadcast current state to all connected clients
+     */
+    private broadcastState;
+    /**
+     * Get current internal state
+     */
+    getState(): PlayerState;
+    /**
+     * Set internal state directly (for sync from external sources)
+     */
+    setState(state: Partial<PlayerState>): void;
     /**
      * Set up graceful shutdown hooks
      */

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

@@ -2,11 +2,28 @@ 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 { getPlayerService } from "../player/player.service.js";
+import { getSearchService } from "../youtube-music/search.service.js";
 import { logger } from "../logger/logger.service.js";
 class WebServerManager {
     config;
     isRunning = false;
     cleanupHooks = [];
+    // Internal state for web-only mode (when PlayerProvider is not mounted)
+    internalState = {
+        currentTrack: null,
+        isPlaying: false,
+        volume: 70,
+        speed: 1,
+        progress: 0,
+        duration: 0,
+        queue: [],
+        queuePosition: 0,
+        repeat: 'off',
+        shuffle: false,
+        isLoading: false,
+        error: null,
+    };
     constructor() {
         // Load config or use defaults
         const configService = getConfigService();
@@ -23,6 +40,8 @@ class WebServerManager {
         if (!savedConfig) {
             configService.set('webServer', this.config);
         }
+        // Initialize volume from config
+        this.internalState.volume = configService.get('volume') ?? 70;
     }
     /**
      * Start the web server
@@ -60,6 +79,8 @@ class WebServerManager {
                 config: finalConfig,
                 onCommand: this.handleCommand.bind(this),
                 onImportRequest: this.handleImportRequest.bind(this),
+                onSearchRequest: this.handleSearchRequest.bind(this),
+                onConfigUpdate: this.handleConfigUpdate.bind(this),
             });
             this.isRunning = true;
             // Set up graceful shutdown
@@ -117,8 +138,195 @@ class WebServerManager {
      * Handle command from web client
      */
     handleCommand(action) {
-        // This will be handled by the player store
-        logger.debug('WebServerManager', 'Received command from client', { action });
+        logger.debug('WebServerManager', 'Executing command from client', { action });
+        const playerService = getPlayerService();
+        // Execute command and update internal state
+        switch (action.category) {
+            case 'PLAY': {
+                if (action.track) {
+                    this.internalState.currentTrack = action.track;
+                    this.internalState.isPlaying = true;
+                    this.internalState.progress = 0;
+                    this.internalState.error = null;
+                    const youtubeUrl = `https://www.youtube.com/watch?v=${action.track.videoId}`;
+                    void playerService.play(youtubeUrl, {
+                        volume: this.internalState.volume,
+                    });
+                }
+                break;
+            }
+            case 'PAUSE':
+                this.internalState.isPlaying = false;
+                playerService.pause();
+                break;
+            case 'RESUME':
+                this.internalState.isPlaying = true;
+                playerService.resume();
+                break;
+            case 'STOP':
+                this.internalState.isPlaying = false;
+                this.internalState.progress = 0;
+                this.internalState.currentTrack = null;
+                playerService.stop();
+                break;
+            case 'NEXT': {
+                if (this.internalState.queue.length === 0)
+                    break;
+                if (this.internalState.shuffle && this.internalState.queue.length > 1) {
+                    let randomIndex;
+                    do {
+                        randomIndex = Math.floor(Math.random() * this.internalState.queue.length);
+                    } while (randomIndex === this.internalState.queuePosition);
+                    this.internalState.queuePosition = randomIndex;
+                }
+                else {
+                    const nextPosition = this.internalState.queuePosition + 1;
+                    if (nextPosition >= this.internalState.queue.length) {
+                        if (this.internalState.repeat === 'all') {
+                            this.internalState.queuePosition = 0;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    else {
+                        this.internalState.queuePosition = nextPosition;
+                    }
+                }
+                this.internalState.currentTrack =
+                    this.internalState.queue[this.internalState.queuePosition] ?? null;
+                this.internalState.isPlaying = true;
+                this.internalState.progress = 0;
+                if (this.internalState.currentTrack) {
+                    const youtubeUrl = `https://www.youtube.com/watch?v=${this.internalState.currentTrack.videoId}`;
+                    void playerService.play(youtubeUrl, {
+                        volume: this.internalState.volume,
+                    });
+                }
+                break;
+            }
+            case 'PREVIOUS': {
+                const prevPosition = this.internalState.queuePosition - 1;
+                if (prevPosition < 0)
+                    break;
+                if (this.internalState.progress > 3) {
+                    this.internalState.progress = 0;
+                    break;
+                }
+                this.internalState.queuePosition = prevPosition;
+                this.internalState.currentTrack =
+                    this.internalState.queue[prevPosition] ?? null;
+                this.internalState.progress = 0;
+                break;
+            }
+            case 'SEEK':
+                if (action.position !== undefined) {
+                    this.internalState.progress = Math.max(0, Math.min(action.position, this.internalState.duration));
+                    // Note: Seeking via mpv IPC would require additional implementation
+                }
+                break;
+            case 'SET_VOLUME':
+                if (action.volume !== undefined) {
+                    this.internalState.volume = Math.max(0, Math.min(100, action.volume));
+                    playerService.setVolume(this.internalState.volume);
+                }
+                break;
+            case 'VOLUME_UP':
+                this.internalState.volume = Math.min(100, this.internalState.volume + 10);
+                playerService.setVolume(this.internalState.volume);
+                break;
+            case 'VOLUME_DOWN':
+                this.internalState.volume = Math.max(0, this.internalState.volume - 10);
+                playerService.setVolume(this.internalState.volume);
+                break;
+            case 'VOLUME_FINE_UP':
+                this.internalState.volume = Math.min(100, this.internalState.volume + 1);
+                playerService.setVolume(this.internalState.volume);
+                break;
+            case 'VOLUME_FINE_DOWN':
+                this.internalState.volume = Math.max(0, this.internalState.volume - 1);
+                playerService.setVolume(this.internalState.volume);
+                break;
+            case 'TOGGLE_SHUFFLE':
+                this.internalState.shuffle = !this.internalState.shuffle;
+                break;
+            case 'TOGGLE_REPEAT': {
+                const repeatModes = ['off', 'all', 'one'];
+                const currentIndex = repeatModes.indexOf(this.internalState.repeat);
+                this.internalState.repeat =
+                    repeatModes[(currentIndex + 1) % 3] ?? 'off';
+                break;
+            }
+            case 'SET_QUEUE':
+                if (action.queue) {
+                    this.internalState.queue = action.queue;
+                    this.internalState.queuePosition = 0;
+                }
+                break;
+            case 'ADD_TO_QUEUE':
+                if (action.track) {
+                    this.internalState.queue = [
+                        ...this.internalState.queue,
+                        action.track,
+                    ];
+                }
+                break;
+            case 'REMOVE_FROM_QUEUE':
+                if (action.index !== undefined) {
+                    const newQueue = [...this.internalState.queue];
+                    newQueue.splice(action.index, 1);
+                    this.internalState.queue = newQueue;
+                }
+                break;
+            case 'CLEAR_QUEUE':
+                this.internalState.queue = [];
+                this.internalState.queuePosition = 0;
+                this.internalState.isPlaying = false;
+                break;
+            case 'SET_QUEUE_POSITION':
+                if (action.position >= 0 &&
+                    action.position < this.internalState.queue.length) {
+                    this.internalState.queuePosition = action.position;
+                    this.internalState.currentTrack =
+                        this.internalState.queue[action.position] ?? null;
+                    this.internalState.progress = 0;
+                }
+                break;
+            case 'SET_SPEED':
+                if (action.speed !== undefined) {
+                    const clampedSpeed = Math.max(0.25, Math.min(4.0, action.speed));
+                    this.internalState.speed = clampedSpeed;
+                    playerService.setSpeed(clampedSpeed);
+                }
+                break;
+            case 'UPDATE_PROGRESS':
+                if (action.progress !== undefined) {
+                    this.internalState.progress = Math.max(0, Math.min(action.progress, this.internalState.duration || action.progress));
+                }
+                break;
+            case 'SET_DURATION':
+                if (action.duration !== undefined) {
+                    this.internalState.duration = action.duration;
+                }
+                break;
+            case 'SET_LOADING':
+                if (action.loading !== undefined) {
+                    this.internalState.isLoading = action.loading;
+                }
+                break;
+            case 'SET_ERROR':
+                if (action.error !== undefined) {
+                    this.internalState.error = action.error;
+                    this.internalState.isLoading = false;
+                }
+                break;
+            default:
+                logger.debug('WebServerManager', 'Unhandled command category', {
+                    category: action.category,
+                });
+        }
+        // Broadcast updated state after command
+        this.broadcastState();
     }
     /**
      * Handle import request from web client
@@ -141,15 +349,90 @@ class WebServerManager {
             });
         }
     }
+    /**
+     * Handle search request from web client
+     */
+    async handleSearchRequest(query, searchType) {
+        logger.info('WebServerManager', 'Search request from client', {
+            query,
+            searchType,
+        });
+        try {
+            const searchService = getSearchService();
+            const response = await searchService.search(query, { type: searchType });
+            const streamingService = getWebStreamingService();
+            streamingService.broadcast({
+                type: 'search-results',
+                results: response.results,
+            });
+        }
+        catch (error) {
+            logger.error('WebServerManager', 'Search failed', {
+                query,
+                searchType,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Handle config update from web client
+     */
+    handleConfigUpdate(config) {
+        logger.info('WebServerManager', 'Config update from client', { config });
+        try {
+            const configService = getConfigService();
+            // Apply each config key
+            for (const [key, value] of Object.entries(config)) {
+                configService.set(key, value);
+            }
+            // Broadcast updated config to all clients
+            const streamingService = getWebStreamingService();
+            streamingService.broadcast({
+                type: 'config-update',
+                config,
+            });
+        }
+        catch (error) {
+            logger.error('WebServerManager', 'Config update failed', {
+                config,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     /**
      * Update player state (call this when player state changes)
+     * This is called by PlayerProvider in normal mode to sync state
      */
     updateState(state) {
         if (!this.isRunning)
             return;
+        // Update internal state to stay in sync
+        this.internalState = { ...state };
         const streamingService = getWebStreamingService();
         streamingService.onStateChange(state);
     }
+    /**
+     * Broadcast current state to all connected clients
+     */
+    broadcastState() {
+        if (!this.isRunning)
+            return;
+        const streamingService = getWebStreamingService();
+        streamingService.onStateChange(this.internalState);
+    }
+    /**
+     * Get current internal state
+     */
+    getState() {
+        return { ...this.internalState };
+    }
+    /**
+     * Set internal state directly (for sync from external sources)
+     */
+    setState(state) {
+        this.internalState = { ...this.internalState, ...state };
+        this.broadcastState();
+    }
     /**
      * Set up graceful shutdown hooks
      */

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

@@ -1,8 +1,11 @@
 import type { WebServerConfig } from '../../types/web.types.ts';
+import type { PlayerAction } from '../../types/player.types.ts';
 interface WebSocketServerOptions {
     config: WebServerConfig;
-    onCommand?: (action: unknown) => void;
+    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;
@@ -12,6 +15,8 @@ declare class WebSocketServerClass {
     private staticFileService;
     private onCommand?;
     private onImportRequest?;
+    private onSearchRequest?;
+    private onConfigUpdate?;
     constructor();
     /**
      * Start the WebSocket server

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

@@ -12,6 +12,8 @@ class WebSocketServerClass {
     staticFileService = getStaticFileService();
     onCommand;
     onImportRequest;
+    onSearchRequest;
+    onConfigUpdate;
     constructor() {
         this.config = {
             enabled: false,
@@ -29,6 +31,8 @@ class WebSocketServerClass {
         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,
@@ -164,6 +168,16 @@ class WebSocketServerClass {
                     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;

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

@@ -130,3 +130,6 @@ export interface SetSearchLimitAction {
 export interface TogglePlayerModeAction {
     readonly category: 'TOGGLE_PLAYER_MODE';
 }
+export interface DetachAction {
+    readonly category: 'DETACH';
+}

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

@@ -36,4 +36,11 @@ export interface Config {
     downloadDirectory?: string;
     downloadFormat?: DownloadFormat;
     webServer?: WebServerConfig;
+    backgroundPlayback?: {
+        enabled: boolean;
+        ipcPath?: string;
+        currentUrl?: string;
+        timestamp?: string;
+    };
+    lastVersionCheck?: string;
 }

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

@@ -1,4 +1,4 @@
-import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction, TogglePlayerModeAction } from './actions.ts';
+import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction, TogglePlayerModeAction, DetachAction } from './actions.ts';
 export interface NavigationState {
     currentView: string;
     previousView: string | null;
@@ -12,4 +12,4 @@ export interface NavigationState {
     history: string[];
     playerMode: 'full' | 'mini';
 }
-export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction | TogglePlayerModeAction;
+export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction | TogglePlayerModeAction | DetachAction;

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

@@ -1,7 +1,8 @@
 import type { PlayerAction, PlayerState } from './player.types.ts';
 import type { ImportProgress, ImportResult } from './import.types.ts';
+import type { Track, Album, Artist, Playlist } from './youtube-music.types.ts';
 /** WebSocket server message types */
-export type ServerMessage = StateUpdateMessage | EventMessage | ErrorMessage | AuthMessage | ImportProgressMessage | ImportResultMessage;
+export type ServerMessage = StateUpdateMessage | EventMessage | ErrorMessage | AuthMessage | ImportProgressMessage | ImportResultMessage | SearchResultsMessage | ConfigUpdateMessage;
 /** Player state update message */
 export interface StateUpdateMessage {
     type: 'state-update';
@@ -35,8 +36,23 @@ export interface ImportResultMessage {
     type: 'import-result';
     data: ImportResult;
 }
+/** Search results message */
+export interface SearchResultsMessage {
+    type: 'search-results';
+    results: SearchResult[];
+}
+/** Search result item */
+export interface SearchResult {
+    type: 'song' | 'album' | 'artist' | 'playlist';
+    data: Track | Album | Artist | Playlist;
+}
+/** Configuration update message */
+export interface ConfigUpdateMessage {
+    type: 'config-update';
+    config: Partial<Config>;
+}
 /** WebSocket client message types */
-export type ClientMessage = CommandMessage | AuthRequestMessage | ImportRequestMessage;
+export type ClientMessage = CommandMessage | AuthRequestMessage | ImportRequestMessage | SearchRequestMessage | ConfigUpdateRequestMessage;
 /** Command message from client */
 export interface CommandMessage {
     type: 'command';
@@ -54,6 +70,28 @@ export interface ImportRequestMessage {
     url: string;
     name?: string;
 }
+/** Search request from client */
+export interface SearchRequestMessage {
+    type: 'search-request';
+    query: string;
+    searchType: 'all' | 'songs' | 'artists' | 'albums' | 'playlists';
+}
+/** Config update request from client */
+export interface ConfigUpdateRequestMessage {
+    type: 'config-update';
+    config: Partial<Config>;
+}
+/** Configuration interface */
+export interface Config {
+    theme: string;
+    volume: number;
+    repeat: 'off' | 'all' | 'one';
+    shuffle: boolean;
+    streamQuality: 'low' | 'medium' | 'high';
+    audioNormalization: boolean;
+    notifications: boolean;
+    discordRichPresence: boolean;
+}
 /** WebSocket client information */
 export interface WebSocketClient {
     id: string;