@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,177 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Plugin store - manages plugin state in the TUI
+import { createContext, useContext, useReducer, useMemo, useEffect, } from 'react';
+import { getPluginRegistryService } from "../services/plugin/plugin-registry.service.js";
+import { getPluginInstallerService } from "../services/plugin/plugin-installer.service.js";
+import { getPluginUpdaterService } from "../services/plugin/plugin-updater.service.js";
+const initialState = {
+    installedPlugins: [],
+    availablePlugins: [],
+    selectedIndex: 0,
+    isLoading: false,
+    error: null,
+    lastAction: null,
+};
+function pluginsReducer(state, action) {
+    switch (action.type) {
+        case 'SET_INSTALLED':
+            return { ...state, installedPlugins: action.plugins };
+        case 'SET_AVAILABLE':
+            return { ...state, availablePlugins: action.plugins };
+        case 'SET_SELECTED':
+            return { ...state, selectedIndex: action.index };
+        case 'SET_LOADING':
+            return { ...state, isLoading: action.loading };
+        case 'SET_ERROR':
+            return { ...state, error: action.error };
+        case 'SET_LAST_ACTION':
+            return { ...state, lastAction: action.action };
+        case 'REFRESH':
+            return { ...state };
+        default:
+            return state;
+    }
+}
+const PluginsContext = createContext(null);
+export function PluginsProvider({ children }) {
+    const [state, dispatch] = useReducer(pluginsReducer, initialState);
+    const registryService = getPluginRegistryService();
+    const installerService = getPluginInstallerService();
+    const updaterService = getPluginUpdaterService();
+    const refreshPlugins = () => {
+        const plugins = registryService.getAllPlugins();
+        dispatch({ type: 'SET_INSTALLED', plugins });
+    };
+    const installPlugin = async (nameOrUrl) => {
+        dispatch({ type: 'SET_LOADING', loading: true });
+        dispatch({ type: 'SET_ERROR', error: null });
+        try {
+            let result;
+            if (nameOrUrl.startsWith('http')) {
+                result = await installerService.installFromGitHub(nameOrUrl);
+            }
+            else {
+                result = await installerService.installFromDefaultRepo(nameOrUrl);
+            }
+            if (result.success) {
+                dispatch({
+                    type: 'SET_LAST_ACTION',
+                    action: `Installed ${result.pluginId}`,
+                });
+                // Reload plugins
+                await registryService.loadAllPlugins();
+                refreshPlugins();
+            }
+            else {
+                dispatch({ type: 'SET_ERROR', error: result.error || 'Install failed' });
+            }
+            return result;
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', loading: false });
+        }
+    };
+    const uninstallPlugin = async (pluginId) => {
+        dispatch({ type: 'SET_LOADING', loading: true });
+        try {
+            // Unload from registry first
+            await registryService.unloadPlugin(pluginId);
+            // Then uninstall from disk
+            const result = await installerService.uninstall(pluginId);
+            if (result.success) {
+                dispatch({
+                    type: 'SET_LAST_ACTION',
+                    action: `Uninstalled ${pluginId}`,
+                });
+                refreshPlugins();
+            }
+            else {
+                dispatch({
+                    type: 'SET_ERROR',
+                    error: result.error || 'Uninstall failed',
+                });
+            }
+            return result;
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', loading: false });
+        }
+    };
+    const enablePlugin = async (pluginId) => {
+        try {
+            await registryService.enablePlugin(pluginId);
+            dispatch({ type: 'SET_LAST_ACTION', action: `Enabled ${pluginId}` });
+            refreshPlugins();
+        }
+        catch (error) {
+            dispatch({
+                type: 'SET_ERROR',
+                error: error instanceof Error ? error.message : 'Enable failed',
+            });
+        }
+    };
+    const disablePlugin = async (pluginId) => {
+        try {
+            await registryService.disablePlugin(pluginId);
+            dispatch({ type: 'SET_LAST_ACTION', action: `Disabled ${pluginId}` });
+            refreshPlugins();
+        }
+        catch (error) {
+            dispatch({
+                type: 'SET_ERROR',
+                error: error instanceof Error ? error.message : 'Disable failed',
+            });
+        }
+    };
+    const updatePlugin = async (pluginId) => {
+        dispatch({ type: 'SET_LOADING', loading: true });
+        try {
+            const result = await updaterService.updatePlugin(pluginId);
+            if (result.success) {
+                dispatch({
+                    type: 'SET_LAST_ACTION',
+                    action: `Updated ${pluginId} to ${result.newVersion}`,
+                });
+                // Reload the plugin
+                await registryService.loadAllPlugins();
+                refreshPlugins();
+            }
+            else {
+                dispatch({ type: 'SET_ERROR', error: result.error || 'Update failed' });
+            }
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', loading: false });
+        }
+    };
+    // Load plugins on mount
+    useEffect(() => {
+        const loadPlugins = async () => {
+            await registryService.loadAllPlugins();
+            const plugins = registryService.getAllPlugins();
+            dispatch({ type: 'SET_INSTALLED', plugins });
+        };
+        void loadPlugins();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const contextValue = useMemo(() => ({
+        state,
+        dispatch,
+        refreshPlugins,
+        installPlugin,
+        uninstallPlugin,
+        enablePlugin,
+        disablePlugin,
+        updatePlugin,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [state]);
+    return (_jsx(PluginsContext.Provider, { value: contextValue, children: children }));
+}
+export function usePlugins() {
+    const context = useContext(PluginsContext);
+    if (!context) {
+        throw new Error('usePlugins must be used within PluginsProvider');
+    }
+    return context;
+}

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

@@ -0,0 +1,119 @@
+import type { Track } from './youtube-music.types.ts';
+export interface PlayAction {
+    readonly category: 'PLAY';
+    track: Track;
+}
+export interface PauseAction {
+    readonly category: 'PAUSE';
+}
+export interface ResumeAction {
+    readonly category: 'RESUME';
+}
+export interface StopAction {
+    readonly category: 'STOP';
+}
+export interface NextAction {
+    readonly category: 'NEXT';
+}
+export interface PreviousAction {
+    readonly category: 'PREVIOUS';
+}
+export interface SeekAction {
+    readonly category: 'SEEK';
+    position: number;
+}
+export interface SetVolumeAction {
+    readonly category: 'SET_VOLUME';
+    volume: number;
+}
+export interface VolumeUpAction {
+    readonly category: 'VOLUME_UP';
+}
+export interface VolumeDownAction {
+    readonly category: 'VOLUME_DOWN';
+}
+export interface ToggleShuffleAction {
+    readonly category: 'TOGGLE_SHUFFLE';
+}
+export interface ToggleRepeatAction {
+    readonly category: 'TOGGLE_REPEAT';
+}
+export interface SetQueueAction {
+    readonly category: 'SET_QUEUE';
+    queue: Track[];
+}
+export interface AddToQueueAction {
+    readonly category: 'ADD_TO_QUEUE';
+    track: Track;
+}
+export interface RemoveFromQueueAction {
+    readonly category: 'REMOVE_FROM_QUEUE';
+    index: number;
+}
+export interface ClearQueueAction {
+    readonly category: 'CLEAR_QUEUE';
+}
+export interface SetQueuePositionAction {
+    readonly category: 'SET_QUEUE_POSITION';
+    position: number;
+}
+export interface UpdateProgressAction {
+    readonly category: 'UPDATE_PROGRESS';
+    progress: number;
+}
+export interface SetDurationAction {
+    readonly category: 'SET_DURATION';
+    duration: number;
+}
+export interface TickAction {
+    readonly category: 'TICK';
+}
+export interface SetLoadingAction {
+    readonly category: 'SET_LOADING';
+    loading: boolean;
+}
+export interface SetErrorAction {
+    readonly category: 'SET_ERROR';
+    error: string | null;
+}
+export interface RestoreStateAction {
+    readonly category: 'RESTORE_STATE';
+    currentTrack: Track | null;
+    queue: Track[];
+    queuePosition: number;
+    progress: number;
+    volume: number;
+    shuffle: boolean;
+    repeat: 'off' | 'all' | 'one';
+}
+export interface NavigateAction {
+    readonly category: 'NAVIGATE';
+    view: string;
+}
+export interface GoBackAction {
+    readonly category: 'GO_BACK';
+}
+export interface SetSearchQueryAction {
+    readonly category: 'SET_SEARCH_QUERY';
+    query: string;
+}
+export interface SetSearchCategoryAction {
+    readonly category: 'SET_SEARCH_CATEGORY';
+    searchType: string;
+}
+export interface SetSelectedResultAction {
+    readonly category: 'SET_SELECTED_RESULT';
+    index: number;
+}
+export interface SetSelectedPlaylistAction {
+    readonly category: 'SET_SELECTED_PLAYLIST';
+    index: number;
+}
+export interface SetHasSearchedAction {
+    readonly category: 'SET_HAS_SEARCHED';
+    hasSearched: boolean;
+}
+export interface SetSearchLimitAction {
+    readonly category: 'SET_SEARCH_LIMIT';
+    limit: number;
+}

package/dist/source/types/actions.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+export interface Flags {
+    help?: boolean;
+    version?: boolean;
+    theme?: string;
+    volume?: number;
+    shuffle?: boolean;
+    repeat?: string;
+    playTrack?: string;
+    searchQuery?: string;
+    playPlaylist?: string;
+    showSuggestions?: boolean;
+    headless?: boolean;
+    action?: 'pause' | 'resume' | 'next' | 'previous';
+}

package/dist/source/types/cli.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+import type { Playlist } from './youtube-music.types.ts';
+import type { Theme } from './theme.types.ts';
+export type RepeatMode = 'off' | 'all' | 'one';
+export interface KeybindingConfig {
+    keys: string[];
+    description: string;
+}
+export interface Config {
+    theme: 'dark' | 'light' | 'midnight' | 'matrix' | 'custom';
+    volume: number;
+    keybindings: Record<string, KeybindingConfig>;
+    playlists: Playlist[];
+    history: string[];
+    favorites: string[];
+    repeat: RepeatMode;
+    shuffle: boolean;
+    customTheme?: Theme;
+    streamQuality?: 'low' | 'medium' | 'high';
+}

package/dist/source/types/config.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+export interface KeyBinding {
+    keys: string[];
+    description: string;
+}
+export type KeyBindings = Record<string, KeyBinding>;

package/dist/source/types/keyboard.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+import type { NavigateAction, GoBackAction, SetSearchQueryAction, SetSearchCategoryAction, SetSelectedResultAction, SetSelectedPlaylistAction, SetHasSearchedAction, SetSearchLimitAction } from './actions.ts';
+export interface NavigationState {
+    currentView: string;
+    previousView: string | null;
+    searchQuery: string;
+    searchCategory: string;
+    searchType: 'all' | 'songs' | 'albums' | 'artists' | 'playlists';
+    selectedResult: number;
+    selectedPlaylist: number;
+    hasSearched: boolean;
+    searchLimit: number;
+    history: string[];
+}
+export type NavigationAction = NavigateAction | GoBackAction | SetSearchQueryAction | SetSearchCategoryAction | SetSelectedResultAction | SetSelectedPlaylistAction | SetHasSearchedAction | SetSearchLimitAction;

package/dist/source/types/navigation.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+import type { PlayAction, PauseAction, ResumeAction, StopAction, NextAction, PreviousAction, SeekAction, SetVolumeAction, VolumeUpAction, VolumeDownAction, ToggleShuffleAction, ToggleRepeatAction, SetQueueAction, AddToQueueAction, RemoveFromQueueAction, ClearQueueAction, SetQueuePositionAction, UpdateProgressAction, SetDurationAction, TickAction, SetLoadingAction, SetErrorAction, RestoreStateAction } from './actions.ts';
+import type { Track } from './youtube-music.types.ts';
+export interface PlayerState {
+    currentTrack: Track | null;
+    isPlaying: boolean;
+    volume: number;
+    progress: number;
+    duration: number;
+    queue: Track[];
+    queuePosition: number;
+    repeat: 'off' | 'all' | 'one';
+    shuffle: boolean;
+    isLoading: boolean;
+    error: string | null;
+}
+export type PlayerAction = PlayAction | PauseAction | ResumeAction | StopAction | NextAction | PreviousAction | SeekAction | SetVolumeAction | VolumeUpAction | VolumeDownAction | ToggleShuffleAction | ToggleRepeatAction | SetQueueAction | AddToQueueAction | RemoveFromQueueAction | ClearQueueAction | SetQueuePositionAction | UpdateProgressAction | SetDurationAction | TickAction | SetLoadingAction | SetErrorAction | RestoreStateAction;

package/dist/source/types/player.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,12 @@
+import type { Track } from './youtube-music.types.ts';
+export interface Playlist {
+    playlistId: string;
+    name: string;
+    tracks: Track[];
+}
+export interface PlaylistEntry {
+    playlistId: string;
+}
+export interface PlaylistWithEntries extends Playlist {
+    entries: PlaylistEntry[];
+}

package/dist/source/types/playlist.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,239 @@
+import type { Track } from './youtube-music.types.ts';
+import type { ReactElement } from 'react';
+/**
+ * Plugin permission types
+ */
+export type PluginPermission = 'filesystem' | 'network' | 'player' | 'ui' | 'config';
+/**
+ * Permission request status
+ */
+export type PermissionStatus = 'granted' | 'denied' | 'prompt';
+/**
+ * Plugin permissions mapping
+ */
+export interface PluginPermissions {
+    [permission: string]: PermissionStatus;
+}
+/**
+ * Player event types
+ */
+export interface PlayerEvent {
+    type: 'play' | 'pause' | 'stop' | 'resume' | 'next' | 'previous' | 'seek' | 'volume-change' | 'track-change' | 'queue-change' | 'shuffle-change' | 'repeat-change';
+    track?: Track;
+    position?: number;
+    volume?: number;
+    queue?: Track[];
+    shuffle?: boolean;
+    repeat?: 'off' | 'all' | 'one';
+    timestamp: number;
+}
+/**
+ * Navigation event types
+ */
+export interface NavigationEvent {
+    type: 'view-change' | 'search' | 'select-result';
+    view?: string;
+    previousView?: string;
+    query?: string;
+    timestamp: number;
+}
+/**
+ * Audio stream event types
+ */
+export interface AudioStreamEvent {
+    type: 'stream-request' | 'stream-start' | 'stream-end' | 'stream-error';
+    url?: string;
+    track?: Track;
+    error?: Error;
+    timestamp: number;
+}
+/**
+ * Plugin event types (union of all event types)
+ */
+export type PluginEvent = PlayerEvent | NavigationEvent | AudioStreamEvent;
+/**
+ * Event handler callback
+ */
+export type EventHandler<T extends PluginEvent = PluginEvent> = (event: T) => void | Promise<void>;
+/**
+ * Plugin manifest - metadata and declarations
+ */
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license?: string;
+    homepage?: string;
+    repository?: string;
+    main: string;
+    permissions: PluginPermission[];
+    hooks?: Array<PlayerEvent['type'] | NavigationEvent['type']>;
+    ui?: {
+        views?: string[];
+        shortcuts?: string[];
+    };
+    dependencies?: Record<string, string>;
+    configSchema?: Record<string, unknown>;
+}
+/**
+ * Plugin configuration
+ */
+export interface PluginConfig {
+    enabled: boolean;
+    config: Record<string, unknown>;
+    permissions: PluginPermissions;
+}
+/**
+ * Player API provided to plugins
+ */
+export interface PluginPlayerAPI {
+    play: (track: Track) => Promise<void>;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    next: () => void;
+    previous: () => void;
+    seek: (position: number) => void;
+    setVolume: (volume: number) => void;
+    getVolume: () => number;
+    getCurrentTrack: () => Track | null;
+    getQueue: () => Track[];
+    addToQueue: (track: Track) => void;
+    removeFromQueue: (index: number) => void;
+    clearQueue: () => void;
+    shuffle: (enabled: boolean) => void;
+    setRepeat: (mode: 'off' | 'all' | 'one') => void;
+}
+/**
+ * Navigation API provided to plugins
+ */
+export interface PluginNavigationAPI {
+    navigate: (view: string) => void;
+    goBack: () => void;
+    getCurrentView: () => string;
+    registerView: (viewId: string, component: ReactElement) => void;
+    unregisterView: (viewId: string) => void;
+}
+/**
+ * Config API provided to plugins
+ */
+export interface PluginConfigAPI {
+    get: <T = unknown>(key: string, defaultValue?: T) => T;
+    set: (key: string, value: unknown) => void;
+    delete: (key: string) => void;
+    getAll: () => Record<string, unknown>;
+}
+/**
+ * Logger API provided to plugins
+ */
+export interface PluginLoggerAPI {
+    debug: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Filesystem API provided to plugins (scoped to plugin data directory)
+ */
+export interface PluginFilesystemAPI {
+    readFile: (path: string) => Promise<string>;
+    writeFile: (path: string, data: string) => Promise<void>;
+    deleteFile: (path: string) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    listFiles: (path?: string) => Promise<string[]>;
+    getDataDir: () => string;
+}
+/**
+ * Audio stream API provided to plugins
+ */
+export interface PluginAudioAPI {
+    transformStreamUrl: (url: string, track: Track) => Promise<string> | string | null;
+    onStreamRequest: (handler: (url: string, track: Track) => Promise<string> | string | null) => void;
+}
+/**
+ * Plugin context - API surface provided to plugins
+ */
+export interface PluginContext {
+    plugin: PluginManifest;
+    player: PluginPlayerAPI;
+    navigation: PluginNavigationAPI;
+    config: PluginConfigAPI;
+    logger: PluginLoggerAPI;
+    filesystem: PluginFilesystemAPI;
+    audio: PluginAudioAPI;
+    on: <T extends PluginEvent = PluginEvent>(eventType: T['type'], handler: EventHandler<T>) => void;
+    off: <T extends PluginEvent = PluginEvent>(eventType: T['type'], handler: EventHandler<T>) => void;
+    emit: <T extends PluginEvent = PluginEvent>(event: T) => void;
+    hasPermission: (permission: PluginPermission) => boolean;
+    requestPermission: (permission: PluginPermission) => Promise<boolean>;
+    registerShortcut: (keys: string[], handler: () => void) => void;
+    unregisterShortcut: (keys: string[]) => void;
+}
+/**
+ * Plugin lifecycle hooks
+ */
+export interface PluginHooks {
+    init?: (context: PluginContext) => Promise<void> | void;
+    enable?: (context: PluginContext) => Promise<void> | void;
+    disable?: (context: PluginContext) => Promise<void> | void;
+    destroy?: (context: PluginContext) => Promise<void> | void;
+}
+/**
+ * Plugin interface - what a plugin module must export
+ */
+export interface Plugin extends PluginHooks {
+    manifest: PluginManifest;
+}
+/**
+ * Plugin instance - runtime representation of a loaded plugin
+ */
+export interface PluginInstance {
+    manifest: PluginManifest;
+    plugin: Plugin;
+    context: PluginContext;
+    config: PluginConfig;
+    enabled: boolean;
+    loadedAt: number;
+}
+/**
+ * Plugin installation result
+ */
+export interface PluginInstallResult {
+    success: boolean;
+    pluginId?: string;
+    error?: string;
+    message?: string;
+}
+/**
+ * Plugin update result
+ */
+export interface PluginUpdateResult {
+    success: boolean;
+    pluginId?: string;
+    oldVersion?: string;
+    newVersion?: string;
+    error?: string;
+    message?: string;
+}
+/**
+ * Available plugin info from repository
+ */
+export interface AvailablePlugin {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    repository: string;
+    installUrl: string;
+    tags?: string[];
+}
+/**
+ * Plugin repository manifest
+ */
+export interface PluginRepositoryManifest {
+    version: string;
+    plugins: AvailablePlugin[];
+}

package/dist/source/types/plugin.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+export type ColorName = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'purple' | 'cyan' | 'white' | 'blackBright' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright' | 'gray';
+export type ThemeColors = {
+    primary: ColorName;
+    secondary: ColorName;
+    background: ColorName;
+    text: ColorName;
+    accent: ColorName;
+    dim: ColorName;
+    error: ColorName;
+    success: ColorName;
+    warning: ColorName;
+};
+export type Theme = {
+    name: string;
+    colors: ThemeColors;
+    inverse?: boolean;
+};
+export type ThemeName = 'dark' | 'light' | 'midnight' | 'matrix' | 'custom';

package/dist/source/types/theme.types.js

@@ -0,0 +1 @@
+export {};