@involvex/youtube-music-cli 0.0.0

package/dist/source/services/player-state/player-state.service.js

@@ -0,0 +1,122 @@
+// Player state persistence service
+import { writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+const STATE_FILE = join(CONFIG_DIR, 'player-state.json');
+const SCHEMA_VERSION = 1;
+const defaultState = {
+    schemaVersion: SCHEMA_VERSION,
+    currentTrack: null,
+    queue: [],
+    queuePosition: 0,
+    progress: 0,
+    volume: 70,
+    shuffle: false,
+    repeat: 'off',
+    lastUpdated: new Date().toISOString(),
+};
+/**
+ * Saves player state to disk
+ */
+export async function savePlayerState(state) {
+    try {
+        // Ensure config directory exists
+        if (!existsSync(CONFIG_DIR)) {
+            await mkdir(CONFIG_DIR, { recursive: true });
+            logger.debug('PlayerStateService', 'Created config directory', {
+                path: CONFIG_DIR,
+            });
+        }
+        // Merge with default state
+        const stateToSave = {
+            ...defaultState,
+            ...state,
+            schemaVersion: SCHEMA_VERSION,
+            lastUpdated: new Date().toISOString(),
+        };
+        // Write to temporary file first, then rename for atomic write
+        const tempFile = `${STATE_FILE}.tmp`;
+        await writeFile(tempFile, JSON.stringify(stateToSave, null, 2), 'utf8');
+        // On Windows, we need to handle the rename differently
+        if (process.platform === 'win32' && existsSync(STATE_FILE)) {
+            // Delete existing file first on Windows
+            await import('node:fs/promises').then(async (fs) => {
+                await fs.unlink(STATE_FILE);
+            });
+        }
+        await import('node:fs/promises').then(async (fs) => {
+            await fs.rename(tempFile, STATE_FILE);
+        });
+        logger.debug('PlayerStateService', 'Saved player state', {
+            hasTrack: !!stateToSave.currentTrack,
+            queueLength: stateToSave.queue.length,
+            progress: stateToSave.progress,
+        });
+    }
+    catch (error) {
+        logger.error('PlayerStateService', 'Failed to save player state', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+    }
+}
+/**
+ * Loads player state from disk
+ */
+export async function loadPlayerState() {
+    try {
+        if (!existsSync(STATE_FILE)) {
+            logger.debug('PlayerStateService', 'No saved state file found');
+            return null;
+        }
+        const data = await readFile(STATE_FILE, 'utf8');
+        const state = JSON.parse(data);
+        // Validate schema version
+        if (state.schemaVersion !== SCHEMA_VERSION) {
+            logger.warn('PlayerStateService', 'Schema version mismatch', {
+                expected: SCHEMA_VERSION,
+                found: state.schemaVersion,
+            });
+            return null;
+        }
+        // Validate state structure
+        if (!state || typeof state !== 'object') {
+            logger.warn('PlayerStateService', 'Invalid state structure');
+            return null;
+        }
+        logger.info('PlayerStateService', 'Loaded player state', {
+            hasTrack: !!state.currentTrack,
+            queueLength: state.queue?.length ?? 0,
+            progress: state.progress,
+            lastUpdated: state.lastUpdated,
+        });
+        return state;
+    }
+    catch (error) {
+        logger.error('PlayerStateService', 'Failed to load player state', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return null;
+    }
+}
+/**
+ * Clears saved player state
+ */
+export async function clearPlayerState() {
+    try {
+        if (existsSync(STATE_FILE)) {
+            await import('node:fs/promises').then(async (fs) => {
+                await fs.unlink(STATE_FILE);
+            });
+            logger.info('PlayerStateService', 'Cleared player state');
+        }
+    }
+    catch (error) {
+        logger.error('PlayerStateService', 'Failed to clear player state', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/source/services/plugin/plugin-audio-api.d.ts

@@ -0,0 +1,17 @@
+import type { Track } from '../../types/youtube-music.types.ts';
+/**
+ * Transform audio URL through all enabled plugins
+ */
+export declare function transformAudioUrl(url: string, track: Track): Promise<string>;
+/**
+ * Notify plugins of stream start
+ */
+export declare function notifyStreamStart(url: string, track: Track): void;
+/**
+ * Notify plugins of stream end
+ */
+export declare function notifyStreamEnd(track: Track): void;
+/**
+ * Notify plugins of stream error
+ */
+export declare function notifyStreamError(error: Error, track?: Track): void;

package/dist/source/services/plugin/plugin-audio-api.js

@@ -0,0 +1,36 @@
+// Plugin audio API integration - hooks for audio stream modification
+import { getPluginHooksService } from "./plugin-hooks.service.js";
+import { logger } from "../logger/logger.service.js";
+/**
+ * Transform audio URL through all enabled plugins
+ */
+export async function transformAudioUrl(url, track) {
+    const hooksService = getPluginHooksService();
+    // Emit stream-request event
+    await hooksService.emit(hooksService.createAudioStreamEvent('stream-request', { url, track }));
+    // For now, return original URL
+    // Plugins will register handlers that can modify this
+    return url;
+}
+/**
+ * Notify plugins of stream start
+ */
+export function notifyStreamStart(url, track) {
+    const hooksService = getPluginHooksService();
+    hooksService.emitSync(hooksService.createAudioStreamEvent('stream-start', { url, track }));
+}
+/**
+ * Notify plugins of stream end
+ */
+export function notifyStreamEnd(track) {
+    const hooksService = getPluginHooksService();
+    hooksService.emitSync(hooksService.createAudioStreamEvent('stream-end', { track }));
+}
+/**
+ * Notify plugins of stream error
+ */
+export function notifyStreamError(error, track) {
+    const hooksService = getPluginHooksService();
+    hooksService.emitSync(hooksService.createAudioStreamEvent('stream-error', { error, track }));
+    logger.error('AudioAPI', 'Stream error:', error);
+}

package/dist/source/services/plugin/plugin-context.d.ts

@@ -0,0 +1,5 @@
+import type { PluginContext, PluginManifest } from '../../types/plugin.types.ts';
+/**
+ * Create a plugin context for a specific plugin
+ */
+export declare function createPluginContext(manifest: PluginManifest, playerAPI: PluginContext['player'], navigationAPI: PluginContext['navigation']): PluginContext;

package/dist/source/services/plugin/plugin-context.js

@@ -0,0 +1,256 @@
+import { getPluginPermissionsService } from "./plugin-permissions.service.js";
+import { getPluginHooksService } from "./plugin-hooks.service.js";
+import { getConfigService } from "../config/config.service.js";
+import { logger as appLogger } from "../logger/logger.service.js";
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { join } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, readdirSync, rmSync, } from 'node:fs';
+/**
+ * Create a plugin context for a specific plugin
+ */
+export function createPluginContext(manifest, playerAPI, navigationAPI) {
+    const permissionsService = getPluginPermissionsService();
+    const hooksService = getPluginHooksService();
+    const configService = getConfigService();
+    const pluginId = manifest.id;
+    // Plugin data directory
+    const pluginDataDir = join(CONFIG_DIR, 'plugins', pluginId, 'data');
+    // Ensure data directory exists
+    if (!existsSync(pluginDataDir)) {
+        mkdirSync(pluginDataDir, { recursive: true });
+    }
+    // Permission checker wrapper
+    const checkPermission = (permission) => {
+        if (!permissionsService.hasPermission(pluginId, permission)) {
+            throw new Error(`Plugin ${pluginId} does not have ${permission} permission`);
+        }
+    };
+    // Create scoped logger for plugin
+    const pluginLogger = {
+        debug: (message, ...args) => {
+            appLogger.debug(`[${manifest.name}]`, message, ...args);
+        },
+        info: (message, ...args) => {
+            appLogger.info(`[${manifest.name}]`, message, ...args);
+        },
+        warn: (message, ...args) => {
+            appLogger.warn(`[${manifest.name}]`, message, ...args);
+        },
+        error: (message, ...args) => {
+            appLogger.error(`[${manifest.name}]`, message, ...args);
+        },
+    };
+    // Filesystem API (scoped to plugin data directory)
+    const filesystemAPI = {
+        readFile: async (path) => {
+            checkPermission('filesystem');
+            const fullPath = join(pluginDataDir, path);
+            return readFileSync(fullPath, 'utf-8');
+        },
+        writeFile: async (path, data) => {
+            checkPermission('filesystem');
+            const fullPath = join(pluginDataDir, path);
+            // Ensure parent directory exists
+            const dir = join(fullPath, '..');
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(fullPath, data, 'utf-8');
+        },
+        deleteFile: async (path) => {
+            checkPermission('filesystem');
+            const fullPath = join(pluginDataDir, path);
+            if (existsSync(fullPath)) {
+                rmSync(fullPath);
+            }
+        },
+        exists: async (path) => {
+            checkPermission('filesystem');
+            const fullPath = join(pluginDataDir, path);
+            return existsSync(fullPath);
+        },
+        listFiles: async (path = '') => {
+            checkPermission('filesystem');
+            const fullPath = join(pluginDataDir, path);
+            if (!existsSync(fullPath)) {
+                return [];
+            }
+            return readdirSync(fullPath);
+        },
+        getDataDir: () => {
+            return pluginDataDir;
+        },
+    };
+    // Config API (scoped to plugin config namespace)
+    const pluginConfigKey = `plugin.${pluginId}`;
+    const configAPI = {
+        get: (key, defaultValue) => {
+            const fullKey = `${pluginConfigKey}.${key}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const value = configService.get(fullKey);
+            return (value ?? defaultValue);
+        },
+        set: (key, value) => {
+            const fullKey = `${pluginConfigKey}.${key}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            configService.set(fullKey, value);
+        },
+        delete: (key) => {
+            const fullKey = `${pluginConfigKey}.${key}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            configService.set(fullKey, undefined);
+        },
+        getAll: () => {
+            // Get all keys starting with plugin config namespace
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const allConfig = configService.get('pluginConfigs');
+            return allConfig?.[pluginId] ?? {};
+        },
+    };
+    // Audio API
+    const audioAPI = {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        transformStreamUrl: async (url, _track) => {
+            checkPermission('player');
+            // Plugins can return modified URL, null to skip, or same URL
+            return url;
+        },
+        onStreamRequest: handler => {
+            checkPermission('player');
+            // Register handler for stream requests
+            hooksService.on('stream-request', async (event) => {
+                if (event.type === 'stream-request' && event.url && event.track) {
+                    await handler(event.url, event.track);
+                }
+            });
+        },
+    };
+    // Player API with permission checks
+    const wrappedPlayerAPI = {
+        play: async (track) => {
+            checkPermission('player');
+            return playerAPI.play(track);
+        },
+        pause: () => {
+            checkPermission('player');
+            playerAPI.pause();
+        },
+        resume: () => {
+            checkPermission('player');
+            playerAPI.resume();
+        },
+        stop: () => {
+            checkPermission('player');
+            playerAPI.stop();
+        },
+        next: () => {
+            checkPermission('player');
+            playerAPI.next();
+        },
+        previous: () => {
+            checkPermission('player');
+            playerAPI.previous();
+        },
+        seek: (position) => {
+            checkPermission('player');
+            playerAPI.seek(position);
+        },
+        setVolume: (volume) => {
+            checkPermission('player');
+            playerAPI.setVolume(volume);
+        },
+        getVolume: () => {
+            checkPermission('player');
+            return playerAPI.getVolume();
+        },
+        getCurrentTrack: () => {
+            checkPermission('player');
+            return playerAPI.getCurrentTrack();
+        },
+        getQueue: () => {
+            checkPermission('player');
+            return playerAPI.getQueue();
+        },
+        addToQueue: (track) => {
+            checkPermission('player');
+            playerAPI.addToQueue(track);
+        },
+        removeFromQueue: (index) => {
+            checkPermission('player');
+            playerAPI.removeFromQueue(index);
+        },
+        clearQueue: () => {
+            checkPermission('player');
+            playerAPI.clearQueue();
+        },
+        shuffle: (enabled) => {
+            checkPermission('player');
+            playerAPI.shuffle(enabled);
+        },
+        setRepeat: (mode) => {
+            checkPermission('player');
+            playerAPI.setRepeat(mode);
+        },
+    };
+    // Navigation API with permission checks
+    const wrappedNavigationAPI = {
+        navigate: (view) => {
+            checkPermission('ui');
+            navigationAPI.navigate(view);
+        },
+        goBack: () => {
+            checkPermission('ui');
+            navigationAPI.goBack();
+        },
+        getCurrentView: () => {
+            checkPermission('ui');
+            return navigationAPI.getCurrentView();
+        },
+        registerView: (viewId, component) => {
+            checkPermission('ui');
+            navigationAPI.registerView(viewId, component);
+        },
+        unregisterView: (viewId) => {
+            checkPermission('ui');
+            navigationAPI.unregisterView(viewId);
+        },
+    };
+    // Event system
+    const context = {
+        plugin: manifest,
+        player: wrappedPlayerAPI,
+        navigation: wrappedNavigationAPI,
+        config: configAPI,
+        logger: pluginLogger,
+        filesystem: filesystemAPI,
+        audio: audioAPI,
+        on: (eventType, handler) => {
+            hooksService.on(eventType, handler);
+        },
+        off: (eventType, handler) => {
+            hooksService.off(eventType, handler);
+        },
+        emit: (event) => {
+            hooksService.emitSync(event);
+        },
+        hasPermission: (permission) => {
+            return permissionsService.hasPermission(pluginId, permission);
+        },
+        requestPermission: async (permission) => {
+            return permissionsService.requestPermission(pluginId, permission);
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        registerShortcut: (_keys, _handler) => {
+            checkPermission('ui');
+            // This will be implemented when we integrate with useKeyBinding
+            pluginLogger.warn('registerShortcut not yet implemented');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        unregisterShortcut: (_keys) => {
+            checkPermission('ui');
+            // This will be implemented when we integrate with useKeyBinding
+            pluginLogger.warn('unregisterShortcut not yet implemented');
+        },
+    };
+    return context;
+}

package/dist/source/services/plugin/plugin-hooks.service.d.ts

@@ -0,0 +1,62 @@
+import type { PluginEvent, EventHandler, PlayerEvent, NavigationEvent, AudioStreamEvent } from '../../types/plugin.types.ts';
+type EventType = PluginEvent['type'];
+/**
+ * Plugin hooks service - manages event subscriptions and emissions
+ */
+declare class PluginHooksService {
+    private handlers;
+    constructor();
+    /**
+     * Register an event handler
+     */
+    on<T extends PluginEvent = PluginEvent>(eventType: T['type'], handler: EventHandler<T>): void;
+    /**
+     * Unregister an event handler
+     */
+    off<T extends PluginEvent = PluginEvent>(eventType: T['type'], handler: EventHandler<T>): void;
+    /**
+     * Emit an event to all registered handlers
+     */
+    emit<T extends PluginEvent = PluginEvent>(event: T): Promise<void>;
+    /**
+     * Emit event synchronously (fire and forget)
+     */
+    emitSync<T extends PluginEvent = PluginEvent>(event: T): void;
+    /**
+     * Remove all handlers for a specific event type
+     */
+    clearHandlers(eventType: EventType): void;
+    /**
+     * Remove all event handlers (used for cleanup)
+     */
+    clearAllHandlers(): void;
+    /**
+     * Get count of handlers for an event type
+     */
+    getHandlerCount(eventType: EventType): number;
+    /**
+     * Get all registered event types
+     */
+    getRegisteredEvents(): EventType[];
+    /**
+     * Helper: Create a player event
+     */
+    createPlayerEvent(type: PlayerEvent['type'], data?: Partial<Omit<PlayerEvent, 'type' | 'timestamp'>>): PlayerEvent;
+    /**
+     * Helper: Create a navigation event
+     */
+    createNavigationEvent(type: NavigationEvent['type'], data?: Partial<Omit<NavigationEvent, 'type' | 'timestamp'>>): NavigationEvent;
+    /**
+     * Helper: Create an audio stream event
+     */
+    createAudioStreamEvent(type: AudioStreamEvent['type'], data?: Partial<Omit<AudioStreamEvent, 'type' | 'timestamp'>>): AudioStreamEvent;
+}
+/**
+ * Get the plugin hooks service singleton
+ */
+export declare function getPluginHooksService(): PluginHooksService;
+/**
+ * Reset the singleton (for testing)
+ */
+export declare function resetPluginHooksService(): void;
+export {};

package/dist/source/services/plugin/plugin-hooks.service.js

@@ -0,0 +1,135 @@
+import { logger } from "../logger/logger.service.js";
+/**
+ * Plugin hooks service - manages event subscriptions and emissions
+ */
+class PluginHooksService {
+    handlers;
+    constructor() {
+        this.handlers = new Map();
+    }
+    /**
+     * Register an event handler
+     */
+    on(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Set());
+        }
+        this.handlers.get(eventType).add(handler);
+        logger.debug('PluginHooksService', `Registered handler for ${eventType}`);
+    }
+    /**
+     * Unregister an event handler
+     */
+    off(eventType, handler) {
+        const handlers = this.handlers.get(eventType);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.handlers.delete(eventType);
+            }
+            logger.debug('PluginHooksService', `Unregistered handler for ${eventType}`);
+        }
+    }
+    /**
+     * Emit an event to all registered handlers
+     */
+    async emit(event) {
+        const handlers = this.handlers.get(event.type);
+        if (!handlers || handlers.size === 0) {
+            return;
+        }
+        logger.debug('PluginHooksService', `Emitting ${event.type} to ${handlers.size} handler(s)`);
+        // Execute all handlers, catching errors to prevent one plugin from breaking others
+        const promises = [];
+        for (const handler of handlers) {
+            promises.push(Promise.resolve()
+                .then(() => handler(event))
+                .catch((error) => {
+                logger.error('PluginHooksService', `Error in handler for ${event.type}:`, error);
+            }));
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Emit event synchronously (fire and forget)
+     */
+    emitSync(event) {
+        void this.emit(event);
+    }
+    /**
+     * Remove all handlers for a specific event type
+     */
+    clearHandlers(eventType) {
+        this.handlers.delete(eventType);
+        logger.debug('PluginHooksService', `Cleared all handlers for ${eventType}`);
+    }
+    /**
+     * Remove all event handlers (used for cleanup)
+     */
+    clearAllHandlers() {
+        this.handlers.clear();
+        logger.debug('PluginHooksService', 'Cleared all event handlers');
+    }
+    /**
+     * Get count of handlers for an event type
+     */
+    getHandlerCount(eventType) {
+        return this.handlers.get(eventType)?.size ?? 0;
+    }
+    /**
+     * Get all registered event types
+     */
+    getRegisteredEvents() {
+        return [...this.handlers.keys()];
+    }
+    /**
+     * Helper: Create a player event
+     */
+    createPlayerEvent(type, data) {
+        return {
+            type,
+            ...data,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Helper: Create a navigation event
+     */
+    createNavigationEvent(type, data) {
+        return {
+            type,
+            ...data,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Helper: Create an audio stream event
+     */
+    createAudioStreamEvent(type, data) {
+        return {
+            type,
+            ...data,
+            timestamp: Date.now(),
+        };
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin hooks service singleton
+ */
+export function getPluginHooksService() {
+    if (!instance) {
+        instance = new PluginHooksService();
+    }
+    return instance;
+}
+/**
+ * Reset the singleton (for testing)
+ */
+export function resetPluginHooksService() {
+    if (instance) {
+        instance.clearAllHandlers();
+    }
+    instance = null;
+}

package/dist/source/services/plugin/plugin-installer.service.d.ts

@@ -0,0 +1,27 @@
+import type { PluginInstallResult } from '../../types/plugin.types.ts';
+/**
+ * Plugin installer service
+ */
+declare class PluginInstallerService {
+    /**
+     * Install a plugin from GitHub repository
+     */
+    installFromGitHub(repoUrl: string, pluginName?: string): Promise<PluginInstallResult>;
+    /**
+     * Install a plugin from the default plugin repository
+     */
+    installFromDefaultRepo(pluginName: string): Promise<PluginInstallResult>;
+    /**
+     * Install a plugin from local directory (for development)
+     */
+    installFromLocal(sourcePath: string): Promise<PluginInstallResult>;
+    /**
+     * Uninstall a plugin
+     */
+    uninstall(pluginId: string): Promise<PluginInstallResult>;
+}
+/**
+ * Get the plugin installer service singleton
+ */
+export declare function getPluginInstallerService(): PluginInstallerService;
+export {};