@involvex/youtube-music-cli 0.0.0

package/dist/source/hooks/useKeyboard.js

@@ -0,0 +1,104 @@
+// Keyboard input handling hook
+import { useCallback, useEffect } from 'react';
+import { useInput } from 'ink';
+import { logger } from "../services/logger/logger.service.js";
+// Global registry for key handlers
+const registry = new Set();
+/**
+ * Hook to bind keyboard shortcuts.
+ * This uses a centralized manager to avoid multiple useInput calls and memory leaks.
+ */
+export function useKeyBinding(keys, handler) {
+    const memoizedHandler = useCallback(handler, [handler]);
+    useEffect(() => {
+        const entry = { keys, handler: memoizedHandler };
+        registry.add(entry);
+        return () => {
+            registry.delete(entry);
+        };
+    }, [keys, memoizedHandler]);
+}
+/**
+ * Global Keyboard Manager Component
+ * This should be rendered once at the root of the app.
+ */
+export function KeyboardManager() {
+    useInput((input, key) => {
+        // Debug logging for key presses (helps diagnose binding issues)
+        if (input || key.ctrl || key.meta || key.shift) {
+            logger.debug('KeyboardManager', 'Key pressed', {
+                input,
+                ctrl: key.ctrl,
+                meta: key.meta,
+                shift: key.shift,
+                upArrow: key.upArrow,
+                downArrow: key.downArrow,
+                leftArrow: key.leftArrow,
+                rightArrow: key.rightArrow,
+            });
+        }
+        // Global quit handling
+        if (key.ctrl && input === 'c') {
+            // Exit cleanly without clearing screen (let Ink handle cleanup)
+            process.exit(0);
+        }
+        // Note: Ctrl+L refresh removed to fix scroll-to-top issue
+        // Direct ANSI escapes bypass Ink's rendering and cause scrolling problems
+        // Dispatch to all registered handlers
+        for (const entry of registry) {
+            const { keys, handler } = entry;
+            for (const binding of keys) {
+                const lowerBinding = binding.toLowerCase();
+                // Handle special keys
+                const isMatch = (lowerBinding === 'escape' && key.escape) ||
+                    ((lowerBinding === 'return' || lowerBinding === 'enter') &&
+                        key.return) ||
+                    (lowerBinding === 'backspace' && key.backspace) ||
+                    (lowerBinding === 'tab' && key.tab) ||
+                    (lowerBinding === 'up' && key.upArrow) ||
+                    (lowerBinding === 'down' && key.downArrow) ||
+                    (lowerBinding === 'left' && key.leftArrow) ||
+                    (lowerBinding === 'right' && key.rightArrow) ||
+                    (lowerBinding === 'pageup' && key.pageUp) ||
+                    (lowerBinding === 'pagedown' && key.pageDown) ||
+                    // Handle combinations
+                    (() => {
+                        const parts = lowerBinding.split('+');
+                        const hasCtrl = parts.includes('ctrl');
+                        const hasMeta = parts.includes('meta') || parts.includes('alt');
+                        const hasShift = parts.includes('shift');
+                        const mainKey = parts[parts.length - 1];
+                        if (hasCtrl && !key.ctrl)
+                            return false;
+                        if (hasMeta && !key.meta)
+                            return false;
+                        if (hasShift && !key.shift)
+                            return false;
+                        // Check the actual key
+                        if (mainKey === 'up' && key.upArrow)
+                            return true;
+                        if (mainKey === 'down' && key.downArrow)
+                            return true;
+                        if (mainKey === 'left' && key.leftArrow)
+                            return true;
+                        if (mainKey === 'right' && key.rightArrow)
+                            return true;
+                        // Handle '=' and '+' specially (+ is shift+=)
+                        if (mainKey === '=' && input === '=')
+                            return true;
+                        if (mainKey === '+' && input === '+')
+                            return true;
+                        if (mainKey === '+' && key.shift && input === '=')
+                            return true; // shift+= produces '+'
+                        return input.toLowerCase() === mainKey && !key.ctrl && !key.meta;
+                    })();
+                if (isMatch) {
+                    handler();
+                    // We don't break here because multiple handlers might want to react
+                    // but usually only one does.
+                }
+            }
+        }
+    });
+    return null;
+}

package/dist/source/hooks/useNavigation.d.ts

@@ -0,0 +1 @@
+export declare function useNavigation(): import("../stores/navigation.store.tsx").NavigationContextValue;

package/dist/source/hooks/useNavigation.js

@@ -0,0 +1,5 @@
+// Navigation hook
+import { useNavigation as useNavigationStore } from "../stores/navigation.store.js";
+export function useNavigation() {
+    return useNavigationStore();
+}

package/dist/source/hooks/usePlayer.d.ts

@@ -0,0 +1,23 @@
+import type { Track } from '../types/youtube-music.types.ts';
+export declare function usePlayer(): {
+    state: import("../types/player.types.ts").PlayerState;
+    dispatch: (action: import("../types/player.types.ts").PlayerAction) => void;
+    play: (track: Track, options?: {
+        clearQueue?: boolean;
+    }) => 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;
+};

package/dist/source/hooks/usePlayer.js

@@ -0,0 +1,35 @@
+// Player hook - audio playback orchestration
+import { useCallback } from 'react';
+import { usePlayer as usePlayerStore } from "../stores/player.store.js";
+import { getConfigService } from "../services/config/config.service.js";
+export function usePlayer() {
+    const { state, dispatch, ...playerStore } = usePlayerStore();
+    const play = useCallback((track, options) => {
+        // Clear queue if requested (e.g., playing from search results)
+        if (options?.clearQueue) {
+            dispatch({ category: 'CLEAR_QUEUE' });
+        }
+        // Add to queue if not already there
+        const isInQueue = state.queue.some(t => t.videoId === track.videoId);
+        if (!isInQueue) {
+            dispatch({ category: 'ADD_TO_QUEUE', track });
+        }
+        // Find position and play
+        const position = state.queue.findIndex(t => t.videoId === track.videoId);
+        if (position >= 0) {
+            dispatch({ category: 'SET_QUEUE_POSITION', position });
+        }
+        else {
+            dispatch({ category: 'PLAY', track });
+        }
+        // Add to history
+        const config = getConfigService();
+        config.addToHistory(track.videoId);
+    }, [state.queue, dispatch]);
+    return {
+        ...playerStore,
+        state,
+        dispatch,
+        play,
+    };
+}

package/dist/source/hooks/usePlaylist.d.ts

@@ -0,0 +1,8 @@
+import type { Playlist, Track } from '../types/youtube-music.types.ts';
+export declare function usePlaylist(): {
+    playlists: Playlist[];
+    createPlaylist: (name: string) => void;
+    deletePlaylist: (playlistId: string) => void;
+    addTrackToPlaylist: (playlistId: string, track: Track) => void;
+    removeTrackFromPlaylist: (playlistId: string, trackIndex: number) => void;
+};

package/dist/source/hooks/usePlaylist.js

@@ -0,0 +1,50 @@
+// Playlist management hook
+import { getConfigService } from "../services/config/config.service.js";
+import { useState, useCallback, useEffect } from 'react';
+export function usePlaylist() {
+    const [playlists, setPlaylists] = useState([]);
+    const configService = getConfigService();
+    useEffect(() => {
+        setPlaylists(configService.get('playlists'));
+    }, []);
+    const createPlaylist = useCallback((name) => {
+        const newPlaylist = {
+            playlistId: Date.now().toString(),
+            name,
+            tracks: [],
+        };
+        const updatedPlaylists = [...playlists, newPlaylist];
+        setPlaylists(updatedPlaylists);
+        configService.set('playlists', updatedPlaylists);
+    }, [playlists, configService]);
+    const deletePlaylist = useCallback((playlistId) => {
+        const updatedPlaylists = playlists.filter(p => p.playlistId !== playlistId);
+        setPlaylists(updatedPlaylists);
+        configService.set('playlists', updatedPlaylists);
+    }, [playlists, configService]);
+    const addTrackToPlaylist = useCallback((playlistId, track) => {
+        const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);
+        if (playlistIndex === -1)
+            return;
+        const updatedPlaylists = [...playlists];
+        updatedPlaylists[playlistIndex].tracks.push(track);
+        setPlaylists(updatedPlaylists);
+        configService.set('playlists', updatedPlaylists);
+    }, [playlists, configService]);
+    const removeTrackFromPlaylist = useCallback((playlistId, trackIndex) => {
+        const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);
+        if (playlistIndex === -1)
+            return;
+        const updatedPlaylists = [...playlists];
+        updatedPlaylists[playlistIndex].tracks.splice(trackIndex, 1);
+        setPlaylists(updatedPlaylists);
+        configService.set('playlists', updatedPlaylists);
+    }, [playlists, configService]);
+    return {
+        playlists,
+        createPlaylist,
+        deletePlaylist,
+        addTrackToPlaylist,
+        removeTrackFromPlaylist,
+    };
+}

package/dist/source/hooks/useSearch.d.ts

@@ -0,0 +1,8 @@
+export declare function useSearch(): {
+    isLoading: boolean;
+    error: string | null;
+    searchSongs: (query: string) => Promise<import("../types/youtube-music.types.ts").Track[]>;
+    searchAlbums: (query: string) => Promise<import("../types/youtube-music.types.ts").Album[]>;
+    searchArtists: (query: string) => Promise<import("../types/youtube-music.types.ts").Artist[]>;
+    searchPlaylists: (query: string) => Promise<import("../types/youtube-music.types.ts").Playlist[]>;
+};

package/dist/source/hooks/useSearch.js

@@ -0,0 +1,76 @@
+// Search hook
+import { getSearchService } from "../services/youtube-music/search.service.js";
+import { useState, useCallback } from 'react';
+export function useSearch() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const searchService = getSearchService();
+    const searchSongs = useCallback(async (query) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const results = await searchService.searchSongs(query);
+            return results;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Search failed');
+            return [];
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [searchService]);
+    const searchAlbums = useCallback(async (query) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const results = await searchService.searchAlbums(query);
+            return results;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Search failed');
+            return [];
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [searchService]);
+    const searchArtists = useCallback(async (query) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const results = await searchService.searchArtists(query);
+            return results;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Search failed');
+            return [];
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [searchService]);
+    const searchPlaylists = useCallback(async (query) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const results = await searchService.searchPlaylists(query);
+            return results;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Search failed');
+            return [];
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [searchService]);
+    return {
+        isLoading,
+        error,
+        searchSongs,
+        searchAlbums,
+        searchArtists,
+        searchPlaylists,
+    };
+}

package/dist/source/hooks/useTerminalSize.d.ts

@@ -0,0 +1,4 @@
+export declare function useTerminalSize(): {
+    columns: number;
+    rows: number;
+};

package/dist/source/hooks/useTerminalSize.js

@@ -0,0 +1,24 @@
+import { useState, useEffect } from 'react';
+import { useStdout } from 'ink';
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({
+        columns: stdout?.columns || 80,
+        rows: stdout?.rows || 24,
+    });
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            setSize({
+                columns: stdout.columns,
+                rows: stdout.rows,
+            });
+        };
+        stdout.on('resize', onResize);
+        return () => {
+            stdout.off('resize', onResize);
+        };
+    }, [stdout]);
+    return size;
+}

package/dist/source/hooks/useTheme.d.ts

@@ -0,0 +1,6 @@
+export declare function useTheme(): {
+    theme: import("../types/theme.types.ts").Theme;
+    themeName: string;
+    setTheme: (name: string) => void;
+    setCustomTheme: (theme: import("../types/theme.types.ts").Theme) => void;
+};

package/dist/source/hooks/useTheme.js

@@ -0,0 +1,5 @@
+// Theme management hook
+import { useTheme as useThemeContext } from "../contexts/theme.context.js";
+export function useTheme() {
+    return useThemeContext();
+}

package/dist/source/hooks/useYouTubeMusic.d.ts

@@ -0,0 +1,11 @@
+import type { SearchOptions, SearchResponse, Track, Album, Artist, Playlist } from '../types/youtube-music.types.ts';
+export declare function useYouTubeMusic(): {
+    isLoading: boolean;
+    error: string | null;
+    search: (query: string, options?: SearchOptions) => Promise<SearchResponse | null>;
+    getTrack: (videoId: string) => Promise<Track | null>;
+    getAlbum: (albumId: string) => Promise<Album | null>;
+    getArtist: (artistId: string) => Promise<Artist | null>;
+    getPlaylist: (playlistId: string) => Promise<Playlist | null>;
+    getSuggestions: (trackId: string) => Promise<Track[]>;
+};

package/dist/source/hooks/useYouTubeMusic.js

@@ -0,0 +1,112 @@
+import { getMusicService } from "../services/youtube-music/api.js";
+import { useState, useCallback } from 'react';
+export function useYouTubeMusic() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const musicService = getMusicService();
+    const search = useCallback(async (query, options = {}) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await musicService.search(query, options);
+            return response;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Search failed');
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    const getTrack = useCallback(async (videoId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const track = await musicService.getTrack(videoId);
+            return track;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to get track');
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    const getAlbum = useCallback(async (albumId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const album = await musicService.getAlbum(albumId);
+            return album;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to get album');
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    const getArtist = useCallback(async (artistId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const artist = await musicService.getArtist(artistId);
+            return artist;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to get artist');
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    const getPlaylist = useCallback(async (playlistId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const playlist = await musicService.getPlaylist(playlistId);
+            return playlist;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to get playlist');
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    const getSuggestions = useCallback(async (trackId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const suggestions = await musicService.getSuggestions(trackId);
+            return suggestions;
+        }
+        catch (err) {
+            // Suppress YouTubeJS parsing errors (library limitation with YouTube's changing API)
+            // These are not user-actionable and create noise in the UI
+            const errorMessage = err instanceof Error ? err.message : 'Failed to get suggestions';
+            if (!errorMessage.includes('ParsingError')) {
+                setError(errorMessage);
+            }
+            return [];
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [musicService]);
+    return {
+        isLoading,
+        error,
+        search,
+        getTrack,
+        getAlbum,
+        getArtist,
+        getPlaylist,
+        getSuggestions,
+    };
+}

package/dist/source/main.d.ts

@@ -0,0 +1,4 @@
+import type { Flags } from './types/cli.types.ts';
+export default function Main({ flags }: {
+    flags?: Flags;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/source/main.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// Main application orchestrator
+import { NavigationProvider } from "./stores/navigation.store.js";
+import { PluginsProvider } from "./stores/plugins.store.js";
+import MainLayout from "./components/layouts/MainLayout.js";
+import { ThemeProvider } from "./contexts/theme.context.js";
+import { PlayerProvider } from "./stores/player.store.js";
+import { ErrorBoundary } from "./components/common/ErrorBoundary.js";
+import { KeyboardManager } from "./hooks/useKeyboard.js";
+import { Box, Text } from 'ink';
+import { useEffect } from 'react';
+import { useNavigation } from "./hooks/useNavigation.js";
+import { usePlayer } from "./hooks/usePlayer.js";
+import { useYouTubeMusic } from "./hooks/useYouTubeMusic.js";
+import { VIEW } from "./utils/constants.js";
+function Initializer({ flags }) {
+    const { dispatch } = useNavigation();
+    const { play } = usePlayer();
+    const { getTrack, getPlaylist } = useYouTubeMusic();
+    useEffect(() => {
+        if (flags?.showSuggestions) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.SUGGESTIONS });
+        }
+        else if (flags?.searchQuery) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.SEARCH });
+            dispatch({ category: 'SET_SEARCH_QUERY', query: flags.searchQuery });
+        }
+        else if (flags?.playTrack) {
+            void getTrack(flags.playTrack).then(track => {
+                if (track)
+                    play(track);
+            });
+        }
+        else if (flags?.playPlaylist) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.PLAYLISTS });
+            void getPlaylist(flags.playPlaylist).then(playlist => {
+                // For now just navigate, but we could auto-play
+                if (playlist) {
+                    dispatch({ category: 'SET_SELECTED_PLAYLIST', index: 0 });
+                }
+            });
+        }
+    }, [flags, dispatch, play, getTrack, getPlaylist]);
+    return null;
+}
+function HeadlessLayout({ flags }) {
+    const { play, pause, resume, next, previous } = usePlayer();
+    const { getTrack } = useYouTubeMusic();
+    useEffect(() => {
+        if (flags?.playTrack) {
+            void getTrack(flags.playTrack).then(track => {
+                if (track)
+                    play(track);
+            });
+        }
+        if (flags?.action === 'pause')
+            pause();
+        if (flags?.action === 'resume')
+            resume();
+        if (flags?.action === 'next')
+            next();
+        if (flags?.action === 'previous')
+            previous();
+    }, [flags, play, pause, resume, next, previous, getTrack]);
+    return (_jsx(Box, { padding: 1, children: _jsx(Text, { color: "green", children: "Headless mode active." }) }));
+}
+export default function Main({ flags }) {
+    return (_jsx(ErrorBoundary, { children: _jsx(ThemeProvider, { children: _jsx(PlayerProvider, { children: _jsx(NavigationProvider, { children: _jsx(PluginsProvider, { children: _jsxs(Box, { flexDirection: "column", children: [_jsx(KeyboardManager, {}), flags?.headless ? (_jsx(HeadlessLayout, { flags: flags })) : (_jsxs(_Fragment, { children: [_jsx(Initializer, { flags: flags }), _jsx(MainLayout, {})] }))] }) }) }) }) }) }));
+}

package/dist/source/services/config/config.service.d.ts

@@ -0,0 +1,26 @@
+import type { Config } from '../../types/config.types.ts';
+import type { Theme } from '../../types/theme.types.ts';
+declare class ConfigService {
+    private configPath;
+    private configDir;
+    private config;
+    constructor();
+    getDefaultConfig(): Config;
+    load(): Config | null;
+    save(): void;
+    get<K extends keyof Config>(key: K): Config[K];
+    set<K extends keyof Config>(key: K, value: Config[K]): void;
+    updateTheme(themeName: string): void;
+    getTheme(): Theme;
+    setCustomTheme(theme: Theme): void;
+    getKeybinding(action: string): string[] | undefined;
+    setKeybinding(action: string, keys: string[]): void;
+    addToHistory(trackId: string): void;
+    getHistory(): string[];
+    addFavorite(trackId: string): void;
+    removeFavorite(trackId: string): void;
+    isFavorite(trackId: string): boolean;
+    getFavorites(): string[];
+}
+export declare function getConfigService(): ConfigService;
+export {};