@involvex/youtube-music-cli 0.0.46 → 0.0.48

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

@@ -1,122 +0,0 @@
-// 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.js

@@ -1,36 +0,0 @@
-// 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.js

@@ -1,256 +0,0 @@
-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.js

@@ -1,135 +0,0 @@
-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;
-}