@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useReducer, useMemo, } from 'react';
+const initialState = {
+    currentView: 'player',
+    previousView: null,
+    searchQuery: '',
+    searchCategory: 'all',
+    searchType: 'all',
+    selectedResult: 0,
+    selectedPlaylist: 0,
+    hasSearched: false,
+    searchLimit: 10,
+    history: [],
+};
+function navigationReducer(state, action) {
+    switch (action.category) {
+        case 'NAVIGATE':
+            return {
+                ...state,
+                currentView: action.view,
+                previousView: state.currentView,
+                history: [...state.history, state.currentView],
+            };
+        case 'GO_BACK':
+            if (state.history.length === 0) {
+                return state;
+            }
+            const previousViews = [...state.history];
+            const backView = previousViews.pop();
+            return {
+                ...state,
+                currentView: backView,
+                previousView: state.currentView,
+                history: previousViews,
+            };
+        case 'SET_SEARCH_QUERY':
+            return { ...state, searchQuery: action.query };
+        case 'SET_SEARCH_CATEGORY':
+            return { ...state, searchCategory: action.category };
+        case 'SET_SELECTED_RESULT':
+            return { ...state, selectedResult: action.index };
+        case 'SET_SELECTED_PLAYLIST':
+            return { ...state, selectedPlaylist: action.index };
+        case 'SET_HAS_SEARCHED':
+            return { ...state, hasSearched: action.hasSearched };
+        case 'SET_SEARCH_LIMIT':
+            return {
+                ...state,
+                searchLimit: Math.max(1, Math.min(50, action.limit)),
+            };
+        default:
+            return state;
+    }
+}
+const NavigationContext = createContext(null);
+export function NavigationProvider({ children }) {
+    const [state, dispatch] = useReducer(navigationReducer, initialState);
+    const contextValue = useMemo(() => ({ state, dispatch }), [state, dispatch]);
+    return (_jsx(NavigationContext.Provider, { value: contextValue, children: children }));
+}
+export function useNavigation() {
+    const context = useContext(NavigationContext);
+    if (!context) {
+        throw new Error('useNavigation must be used within NavigationProvider');
+    }
+    return context;
+}

package/dist/source/stores/player.store.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import type { PlayerState, PlayerAction } from '../types/player.types.ts';
+import type { Track } from '../types/youtube-music.types.ts';
+type PlayerContextValue = {
+    state: PlayerState;
+    dispatch: (action: PlayerAction) => void;
+    play: (track: Track) => void;
+    pause: () => void;
+    resume: () => void;
+    next: () => void;
+    previous: () => void;
+    seek: (position: number) => void;
+    setVolume: (volume: number) => void;
+    volumeUp: () => void;
+    volumeDown: () => void;
+    toggleShuffle: () => void;
+    toggleRepeat: () => void;
+    setQueue: (queue: Track[]) => void;
+    addToQueue: (track: Track) => void;
+    removeFromQueue: (index: number) => void;
+    clearQueue: () => void;
+    setQueuePosition: (position: number) => void;
+};
+export declare function PlayerProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function usePlayer(): PlayerContextValue;
+export {};

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

@@ -0,0 +1,458 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Player store - manages player state
+import { createContext, useContext, useReducer, useEffect, useRef, } from 'react';
+import { getPlayerService } from "../services/player/player.service.js";
+import { loadPlayerState, savePlayerState, } from "../services/player-state/player-state.service.js";
+import { logger } from "../services/logger/logger.service.js";
+const initialState = {
+    currentTrack: null,
+    isPlaying: false,
+    volume: 70,
+    progress: 0,
+    duration: 0,
+    queue: [],
+    queuePosition: 0,
+    repeat: 'off',
+    shuffle: false,
+    isLoading: false,
+    error: null,
+};
+// Get player service instance
+const playerService = getPlayerService();
+function playerReducer(state, action) {
+    switch (action.category) {
+        case 'PLAY':
+            return {
+                ...state,
+                currentTrack: action.track,
+                isPlaying: true,
+                progress: 0,
+                error: null,
+            };
+        case 'PAUSE':
+            return { ...state, isPlaying: false };
+        case 'RESUME':
+            return { ...state, isPlaying: true };
+        case 'STOP':
+            return {
+                ...state,
+                isPlaying: false,
+                progress: 0,
+                currentTrack: null,
+            };
+        case 'NEXT':
+            const nextPosition = state.queuePosition + 1;
+            if (nextPosition >= state.queue.length) {
+                if (state.repeat === 'all') {
+                    return {
+                        ...state,
+                        queuePosition: 0,
+                        currentTrack: state.queue[0] ?? null,
+                        progress: 0,
+                    };
+                }
+                return state;
+            }
+            return {
+                ...state,
+                queuePosition: nextPosition,
+                currentTrack: state.queue[nextPosition] ?? null,
+                progress: 0,
+            };
+        case 'PREVIOUS':
+            const prevPosition = state.queuePosition - 1;
+            if (prevPosition < 0) {
+                return state;
+            }
+            if (state.progress > 3) {
+                return {
+                    ...state,
+                    progress: 0,
+                };
+            }
+            return {
+                ...state,
+                queuePosition: prevPosition,
+                currentTrack: state.queue[prevPosition] ?? null,
+                progress: 0,
+            };
+        case 'SEEK':
+            return {
+                ...state,
+                progress: Math.max(0, Math.min(action.position, state.duration)),
+            };
+        case 'SET_VOLUME': {
+            const newVolume = Math.max(0, Math.min(100, action.volume));
+            playerService.setVolume(newVolume);
+            return { ...state, volume: newVolume };
+        }
+        case 'VOLUME_UP': {
+            const newVolume = Math.min(100, state.volume + 10);
+            logger.debug('PlayerReducer', 'VOLUME_UP', {
+                oldVolume: state.volume,
+                newVolume,
+            });
+            playerService.setVolume(newVolume);
+            return { ...state, volume: newVolume };
+        }
+        case 'VOLUME_DOWN': {
+            const newVolume = Math.max(0, state.volume - 10);
+            logger.debug('PlayerReducer', 'VOLUME_DOWN', {
+                oldVolume: state.volume,
+                newVolume,
+            });
+            playerService.setVolume(newVolume);
+            return { ...state, volume: newVolume };
+        }
+        case 'TOGGLE_SHUFFLE':
+            return { ...state, shuffle: !state.shuffle };
+        case 'TOGGLE_REPEAT':
+            const repeatModes = ['off', 'all', 'one'];
+            const currentIndex = repeatModes.indexOf(state.repeat);
+            const nextRepeat = repeatModes[(currentIndex + 1) % 3] ?? 'off';
+            return { ...state, repeat: nextRepeat };
+        case 'SET_QUEUE':
+            return {
+                ...state,
+                queue: action.queue,
+                queuePosition: 0,
+            };
+        case 'ADD_TO_QUEUE':
+            return { ...state, queue: [...state.queue, action.track] };
+        case 'REMOVE_FROM_QUEUE':
+            const newQueue = [...state.queue];
+            newQueue.splice(action.index, 1);
+            return { ...state, queue: newQueue };
+        case 'CLEAR_QUEUE':
+            return {
+                ...state,
+                queue: [],
+                queuePosition: 0,
+                isPlaying: false,
+            };
+        case 'SET_QUEUE_POSITION':
+            if (action.position >= 0 && action.position < state.queue.length) {
+                return {
+                    ...state,
+                    queuePosition: action.position,
+                    currentTrack: state.queue[action.position] ?? null,
+                    progress: 0,
+                };
+            }
+            return state;
+        case 'UPDATE_PROGRESS':
+            return { ...state, progress: action.progress };
+        case 'SET_DURATION':
+            return { ...state, duration: action.duration };
+        case 'TICK':
+            if (state.isPlaying) {
+                return { ...state, progress: state.progress + 1 };
+            }
+            return state;
+        case 'SET_LOADING':
+            return { ...state, isLoading: action.loading };
+        case 'SET_ERROR':
+            return { ...state, error: action.error, isLoading: false };
+        case 'RESTORE_STATE':
+            logger.info('PlayerReducer', 'RESTORE_STATE', {
+                hasTrack: !!action.currentTrack,
+                queueLength: action.queue.length,
+            });
+            return {
+                ...state,
+                currentTrack: action.currentTrack,
+                queue: action.queue,
+                queuePosition: action.queuePosition,
+                progress: action.progress,
+                volume: action.volume,
+                shuffle: action.shuffle,
+                repeat: action.repeat,
+                isPlaying: false, // Don't auto-play restored state
+            };
+        default:
+            return state;
+    }
+}
+import { getConfigService } from "../services/config/config.service.js";
+import { getMusicService } from "../services/youtube-music/api.js";
+import { useMemo } from 'react';
+const PlayerContext = createContext(null);
+function PlayerManager() {
+    const { state, dispatch, next } = usePlayer();
+    const progressIntervalRef = useRef(null);
+    const musicService = getMusicService();
+    const playerService = getPlayerService();
+    // Register event handler for mpv IPC events
+    useEffect(() => {
+        let lastProgressUpdate = 0;
+        const PROGRESS_THROTTLE_MS = 1000; // Update progress max once per second
+        playerService.onEvent(event => {
+            if (event.duration !== undefined) {
+                dispatch({ category: 'SET_DURATION', duration: event.duration });
+            }
+            if (event.timePos !== undefined) {
+                // Throttle progress updates to reduce re-renders
+                const now = Date.now();
+                if (now - lastProgressUpdate >= PROGRESS_THROTTLE_MS) {
+                    dispatch({ category: 'UPDATE_PROGRESS', progress: event.timePos });
+                    lastProgressUpdate = now;
+                }
+            }
+            if (event.paused !== undefined) {
+                if (event.paused) {
+                    dispatch({ category: 'PAUSE' });
+                }
+                else {
+                    dispatch({ category: 'RESUME' });
+                }
+            }
+            if (event.eof) {
+                // Track ended, play next
+                next();
+            }
+        });
+    }, [playerService, dispatch, next]);
+    // Initialize audio on mount
+    useEffect(() => {
+        const config = getConfigService();
+        dispatch({ category: 'SET_VOLUME', volume: config.get('volume') });
+        const currentInterval = progressIntervalRef.current;
+        return () => {
+            if (currentInterval) {
+                clearInterval(currentInterval);
+            }
+            playerService.stop();
+        };
+    }, [dispatch, playerService]);
+    // Handle track changes
+    useEffect(() => {
+        const track = state.currentTrack;
+        if (!track) {
+            logger.debug('PlayerManager', 'No current track');
+            return;
+        }
+        // Guard: Don't auto-play during initial state restoration
+        if (!state.isPlaying) {
+            logger.info('PlayerManager', 'Skipping auto-play (not playing)', {
+                title: track.title,
+                isPlaying: state.isPlaying,
+            });
+            return;
+        }
+        // Guard: Only play if track actually changed
+        const currentTrackId = playerService.getCurrentTrackId?.() || '';
+        if (currentTrackId === track.videoId) {
+            logger.debug('PlayerManager', 'Track already playing, skipping', {
+                videoId: track.videoId,
+            });
+            return;
+        }
+        logger.info('PlayerManager', 'Loading track', {
+            title: track.title,
+            videoId: track.videoId,
+        });
+        const loadAndPlayTrack = async () => {
+            dispatch({ category: 'SET_LOADING', loading: true });
+            try {
+                logger.debug('PlayerManager', 'Starting playback with mpv', {
+                    videoId: track.videoId,
+                    volume: state.volume,
+                });
+                // Pass YouTube URL directly to mpv (it handles stream extraction via yt-dlp)
+                const youtubeUrl = `https://www.youtube.com/watch?v=${track.videoId}`;
+                await playerService.play(youtubeUrl, {
+                    volume: state.volume,
+                });
+                logger.info('PlayerManager', 'Playback started successfully');
+                dispatch({ category: 'SET_LOADING', loading: false });
+            }
+            catch (error) {
+                logger.error('PlayerManager', 'Failed to load track', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                    track: { title: track.title, videoId: track.videoId },
+                });
+                dispatch({
+                    category: 'SET_ERROR',
+                    error: error instanceof Error ? error.message : 'Failed to load track',
+                });
+            }
+        };
+        void loadAndPlayTrack();
+        // Note: state.volume intentionally excluded - volume changes should not restart playback
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.currentTrack, dispatch, musicService]);
+    // Handle progress tracking
+    useEffect(() => {
+        if (state.isPlaying && state.currentTrack) {
+            const interval = setInterval(() => {
+                dispatch({ category: 'TICK' });
+            }, 1000);
+            return () => {
+                clearInterval(interval);
+            };
+        }
+        return undefined;
+    }, [state.isPlaying, state.currentTrack, dispatch]);
+    // Handle play/pause state
+    useEffect(() => {
+        if (!state.isPlaying) {
+            playerService.pause();
+        }
+    }, [state.isPlaying, playerService]);
+    // Handle volume changes
+    useEffect(() => {
+        const config = getConfigService();
+        config.set('volume', state.volume);
+    }, [state.volume]);
+    // Handle track completion
+    useEffect(() => {
+        if (state.duration > 0 && state.progress >= state.duration) {
+            if (state.repeat === 'one') {
+                dispatch({ category: 'SEEK', position: 0 });
+            }
+            else {
+                next();
+            }
+        }
+    }, [state.progress, state.duration, state.repeat, next, dispatch]);
+    return null;
+}
+export function PlayerProvider({ children }) {
+    const [state, dispatch] = useReducer(playerReducer, initialState);
+    const saveTimeoutRef = useRef(null);
+    const isInitializedRef = useRef(false);
+    // Load persisted state on mount
+    useEffect(() => {
+        void loadPlayerState().then(persistedState => {
+            if (persistedState && !isInitializedRef.current) {
+                logger.info('PlayerProvider', 'Restoring persisted state', {
+                    hasTrack: !!persistedState.currentTrack,
+                    queueLength: persistedState.queue.length,
+                    progress: persistedState.progress,
+                });
+                // Mark as initialized BEFORE dispatch to prevent re-triggers
+                isInitializedRef.current = true;
+                // Restore all state atomically with single dispatch
+                dispatch({
+                    category: 'RESTORE_STATE',
+                    currentTrack: persistedState.currentTrack,
+                    queue: persistedState.queue,
+                    queuePosition: persistedState.queuePosition,
+                    progress: persistedState.progress,
+                    volume: persistedState.volume,
+                    shuffle: persistedState.shuffle,
+                    repeat: persistedState.repeat,
+                });
+            }
+        });
+    }, []);
+    // Save state on changes (debounced for progress updates)
+    useEffect(() => {
+        // Don't save during initial load
+        if (!isInitializedRef.current)
+            return;
+        // Debounce saves (every 5 seconds for progress, immediate for other changes)
+        if (saveTimeoutRef.current) {
+            clearTimeout(saveTimeoutRef.current);
+        }
+        saveTimeoutRef.current = setTimeout(() => {
+            void savePlayerState({
+                currentTrack: state.currentTrack,
+                queue: state.queue,
+                queuePosition: state.queuePosition,
+                progress: state.progress,
+                volume: state.volume,
+                shuffle: state.shuffle,
+                repeat: state.repeat,
+            });
+        }, 
+        // Debounce progress updates (5s), immediate for track/queue changes
+        state.progress > 0 ? 5000 : 0);
+        return () => {
+            if (saveTimeoutRef.current) {
+                clearTimeout(saveTimeoutRef.current);
+            }
+        };
+    }, [
+        state.currentTrack,
+        state.queue,
+        state.queuePosition,
+        state.progress,
+        state.volume,
+        state.shuffle,
+        state.repeat,
+    ]);
+    // Save immediately on unmount/quit
+    useEffect(() => {
+        const stateRef = { current: state }; // Capture state in ref for exit handler
+        const handleExit = () => {
+            const currentState = stateRef.current;
+            void savePlayerState({
+                currentTrack: currentState.currentTrack,
+                queue: currentState.queue,
+                queuePosition: currentState.queuePosition,
+                progress: currentState.progress,
+                volume: currentState.volume,
+                shuffle: currentState.shuffle,
+                repeat: currentState.repeat,
+            });
+        };
+        process.on('beforeExit', handleExit);
+        process.on('SIGINT', handleExit);
+        process.on('SIGTERM', handleExit);
+        // Update ref when state changes
+        stateRef.current = state;
+        return () => {
+            handleExit(); // Save on component unmount
+            process.off('beforeExit', handleExit);
+            process.off('SIGINT', handleExit);
+            process.off('SIGTERM', handleExit);
+        };
+        // Only register handlers once, update via ref
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const actions = useMemo(() => ({
+        play: (track) => {
+            logger.info('PlayerProvider', 'play() action dispatched', {
+                title: track.title,
+                videoId: track.videoId,
+            });
+            dispatch({ category: 'PLAY', track });
+        },
+        pause: () => dispatch({ category: 'PAUSE' }),
+        resume: () => dispatch({ category: 'RESUME' }),
+        next: () => dispatch({ category: 'NEXT' }),
+        previous: () => dispatch({ category: 'PREVIOUS' }),
+        seek: (position) => dispatch({ category: 'SEEK', position }),
+        setVolume: (volume) => dispatch({ category: 'SET_VOLUME', volume }),
+        volumeUp: () => {
+            logger.debug('PlayerActions', 'volumeUp called');
+            dispatch({ category: 'VOLUME_UP' });
+        },
+        volumeDown: () => {
+            logger.debug('PlayerActions', 'volumeDown called');
+            dispatch({ category: 'VOLUME_DOWN' });
+        },
+        toggleShuffle: () => dispatch({ category: 'TOGGLE_SHUFFLE' }),
+        toggleRepeat: () => dispatch({ category: 'TOGGLE_REPEAT' }),
+        setQueue: (queue) => dispatch({ category: 'SET_QUEUE', queue }),
+        addToQueue: (track) => dispatch({ category: 'ADD_TO_QUEUE', track }),
+        removeFromQueue: (index) => dispatch({ category: 'REMOVE_FROM_QUEUE', index }),
+        clearQueue: () => dispatch({ category: 'CLEAR_QUEUE' }),
+        setQueuePosition: (position) => dispatch({ category: 'SET_QUEUE_POSITION', position }),
+    }), [dispatch]);
+    const contextValue = useMemo(() => ({
+        state,
+        dispatch, // Needed by PlayerManager
+        ...actions,
+    }), [state, dispatch, actions]);
+    return (_jsxs(PlayerContext.Provider, { value: contextValue, children: [_jsx(PlayerManager, {}), children] }));
+}
+export function usePlayer() {
+    const context = useContext(PlayerContext);
+    if (!context) {
+        throw new Error('usePlayer must be used within PlayerProvider');
+    }
+    return context;
+}

package/dist/source/stores/plugins.store.d.ts

@@ -0,0 +1,46 @@
+import { type ReactNode } from 'react';
+import type { PluginInstance, AvailablePlugin, PluginInstallResult } from '../types/plugin.types.ts';
+interface PluginsState {
+    installedPlugins: PluginInstance[];
+    availablePlugins: AvailablePlugin[];
+    selectedIndex: number;
+    isLoading: boolean;
+    error: string | null;
+    lastAction: string | null;
+}
+type PluginsAction = {
+    type: 'SET_INSTALLED';
+    plugins: PluginInstance[];
+} | {
+    type: 'SET_AVAILABLE';
+    plugins: AvailablePlugin[];
+} | {
+    type: 'SET_SELECTED';
+    index: number;
+} | {
+    type: 'SET_LOADING';
+    loading: boolean;
+} | {
+    type: 'SET_ERROR';
+    error: string | null;
+} | {
+    type: 'SET_LAST_ACTION';
+    action: string | null;
+} | {
+    type: 'REFRESH';
+};
+interface PluginsContextValue {
+    state: PluginsState;
+    dispatch: React.Dispatch<PluginsAction>;
+    refreshPlugins: () => void;
+    installPlugin: (nameOrUrl: string) => Promise<PluginInstallResult>;
+    uninstallPlugin: (pluginId: string) => Promise<PluginInstallResult>;
+    enablePlugin: (pluginId: string) => Promise<void>;
+    disablePlugin: (pluginId: string) => Promise<void>;
+    updatePlugin: (pluginId: string) => Promise<void>;
+}
+export declare function PluginsProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function usePlugins(): PluginsContextValue;
+export {};