@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,194 @@
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { logger } from "../logger/logger.service.js";
+import { join } from 'node:path';
+const PERMISSIONS_FILE = join(CONFIG_DIR, 'plugin-permissions.json');
+/**
+ * Plugin permissions service - manages permission grants and denials
+ */
+class PluginPermissionsService {
+    permissions;
+    permissionsPath;
+    configDir;
+    // Permission request callback (can be overridden for testing or custom UI)
+    onPermissionRequest;
+    constructor() {
+        this.configDir = CONFIG_DIR;
+        this.permissionsPath = PERMISSIONS_FILE;
+        this.permissions = this.load();
+    }
+    /**
+     * Load permissions from disk
+     */
+    load() {
+        try {
+            if (!existsSync(this.permissionsPath)) {
+                return {};
+            }
+            const data = readFileSync(this.permissionsPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            logger.error('PluginPermissionsService', 'Failed to load permissions:', error);
+            return {};
+        }
+    }
+    /**
+     * Save permissions to disk
+     */
+    save() {
+        try {
+            // Ensure config directory exists
+            if (!existsSync(this.configDir)) {
+                mkdirSync(this.configDir, { recursive: true });
+            }
+            writeFileSync(this.permissionsPath, JSON.stringify(this.permissions, null, 2));
+            logger.debug('PluginPermissionsService', 'Saved permissions to disk');
+        }
+        catch (error) {
+            logger.error('PluginPermissionsService', 'Failed to save permissions:', error);
+        }
+    }
+    /**
+     * Check if a plugin has a specific permission
+     */
+    hasPermission(pluginId, permission) {
+        const pluginPerms = this.permissions[pluginId];
+        if (!pluginPerms) {
+            return false;
+        }
+        return pluginPerms[permission] === 'granted';
+    }
+    /**
+     * Get permission status
+     */
+    getPermissionStatus(pluginId, permission) {
+        const pluginPerms = this.permissions[pluginId];
+        if (!pluginPerms || !pluginPerms[permission]) {
+            return 'prompt';
+        }
+        return pluginPerms[permission];
+    }
+    /**
+     * Get all permissions for a plugin
+     */
+    getPermissions(pluginId) {
+        return this.permissions[pluginId] || {};
+    }
+    /**
+     * Grant a permission to a plugin
+     */
+    grantPermission(pluginId, permission) {
+        if (!this.permissions[pluginId]) {
+            this.permissions[pluginId] = {};
+        }
+        this.permissions[pluginId][permission] = 'granted';
+        this.save();
+        logger.info('PluginPermissionsService', `Granted ${permission} to ${pluginId}`);
+    }
+    /**
+     * Deny a permission to a plugin
+     */
+    denyPermission(pluginId, permission) {
+        if (!this.permissions[pluginId]) {
+            this.permissions[pluginId] = {};
+        }
+        this.permissions[pluginId][permission] = 'denied';
+        this.save();
+        logger.info('PluginPermissionsService', `Denied ${permission} to ${pluginId}`);
+    }
+    /**
+     * Request permission from user
+     */
+    async requestPermission(pluginId, permission) {
+        const currentStatus = this.getPermissionStatus(pluginId, permission);
+        // If already granted or denied, return cached result
+        if (currentStatus === 'granted') {
+            return true;
+        }
+        if (currentStatus === 'denied') {
+            return false;
+        }
+        // Prompt user
+        if (this.onPermissionRequest) {
+            try {
+                const granted = await this.onPermissionRequest(pluginId, permission);
+                if (granted) {
+                    this.grantPermission(pluginId, permission);
+                }
+                else {
+                    this.denyPermission(pluginId, permission);
+                }
+                return granted;
+            }
+            catch (error) {
+                logger.error('PluginPermissionsService', 'Error requesting permission:', error);
+                // Default to deny on error
+                this.denyPermission(pluginId, permission);
+                return false;
+            }
+        }
+        // No callback registered - default to deny for security
+        logger.warn('PluginPermissionsService', `No permission request handler, denying ${permission} for ${pluginId}`);
+        this.denyPermission(pluginId, permission);
+        return false;
+    }
+    /**
+     * Grant multiple permissions at once
+     */
+    grantPermissions(pluginId, permissions) {
+        for (const permission of permissions) {
+            this.grantPermission(pluginId, permission);
+        }
+    }
+    /**
+     * Revoke a permission
+     */
+    revokePermission(pluginId, permission) {
+        if (!this.permissions[pluginId]) {
+            return;
+        }
+        delete this.permissions[pluginId][permission];
+        this.save();
+        logger.info('PluginPermissionsService', `Revoked ${permission} from ${pluginId}`);
+    }
+    /**
+     * Revoke all permissions for a plugin
+     */
+    revokeAllPermissions(pluginId) {
+        delete this.permissions[pluginId];
+        this.save();
+        logger.info('PluginPermissionsService', `Revoked all permissions from ${pluginId}`);
+    }
+    /**
+     * Get all plugin IDs with permissions
+     */
+    getAllPluginIds() {
+        return Object.keys(this.permissions);
+    }
+    /**
+     * Reset all permissions (for testing or user request)
+     */
+    resetAll() {
+        this.permissions = {};
+        this.save();
+        logger.info('PluginPermissionsService', 'Reset all permissions');
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin permissions service singleton
+ */
+export function getPluginPermissionsService() {
+    if (!instance) {
+        instance = new PluginPermissionsService();
+    }
+    return instance;
+}
+/**
+ * Reset the singleton (for testing)
+ */
+export function resetPluginPermissionsService() {
+    instance = null;
+}

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

@@ -0,0 +1,76 @@
+import type { PluginInstance, PluginPermissions } from '../../types/plugin.types.ts';
+/**
+ * Plugin registry service - manages all loaded plugins
+ */
+declare class PluginRegistryService {
+    private plugins;
+    private pluginLoader;
+    private permissionsService;
+    private configService;
+    constructor();
+    /**
+     * Load a plugin from a directory
+     */
+    loadPlugin(pluginPath: string): Promise<PluginInstance>;
+    /**
+     * Unload a plugin
+     */
+    unloadPlugin(pluginId: string): Promise<void>;
+    /**
+     * Enable a plugin
+     */
+    enablePlugin(pluginId: string): Promise<void>;
+    /**
+     * Disable a plugin
+     */
+    disablePlugin(pluginId: string): Promise<void>;
+    /**
+     * Get a plugin instance
+     */
+    getPlugin(pluginId: string): PluginInstance | undefined;
+    /**
+     * Get all plugins
+     */
+    getAllPlugins(): PluginInstance[];
+    /**
+     * Get enabled plugins
+     */
+    getEnabledPlugins(): PluginInstance[];
+    /**
+     * Check if a plugin is loaded
+     */
+    isLoaded(pluginId: string): boolean;
+    /**
+     * Check if a plugin is enabled
+     */
+    isEnabled(pluginId: string): boolean;
+    /**
+     * Get plugin permissions
+     */
+    getPermissions(pluginId: string): PluginPermissions;
+    /**
+     * Load all plugins from the plugins directory
+     */
+    loadAllPlugins(): Promise<void>;
+    /**
+     * Save plugin enabled/disabled state to config
+     */
+    private savePluginState;
+    /**
+     * Get saved plugin state from config
+     */
+    private getSavedPluginState;
+    /**
+     * Clear all plugins
+     */
+    unloadAllPlugins(): Promise<void>;
+}
+/**
+ * Get the plugin registry service singleton
+ */
+export declare function getPluginRegistryService(): PluginRegistryService;
+/**
+ * Reset the singleton (for testing)
+ */
+export declare function resetPluginRegistryService(): void;
+export {};

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

@@ -0,0 +1,215 @@
+import { getPluginLoaderService } from "./plugin-loader.service.js";
+import { getPluginPermissionsService } from "./plugin-permissions.service.js";
+import { getConfigService } from "../config/config.service.js";
+import { logger } from "../logger/logger.service.js";
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { join } from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
+const PLUGINS_DIR = join(CONFIG_DIR, 'plugins');
+/**
+ * Plugin registry service - manages all loaded plugins
+ */
+class PluginRegistryService {
+    plugins;
+    pluginLoader = getPluginLoaderService();
+    permissionsService = getPluginPermissionsService();
+    configService = getConfigService();
+    constructor() {
+        this.plugins = new Map();
+    }
+    /**
+     * Load a plugin from a directory
+     */
+    async loadPlugin(pluginPath) {
+        const instance = await this.pluginLoader.loadPlugin(pluginPath);
+        // Check if already loaded
+        if (this.plugins.has(instance.manifest.id)) {
+            throw new Error(`Plugin ${instance.manifest.id} is already loaded`);
+        }
+        // Store in registry
+        this.plugins.set(instance.manifest.id, instance);
+        logger.info('PluginRegistryService', `Registered plugin: ${instance.manifest.name}`);
+        return instance;
+    }
+    /**
+     * Unload a plugin
+     */
+    async unloadPlugin(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not loaded`);
+        }
+        // Call destroy hook if enabled
+        if (instance.enabled && instance.plugin.destroy) {
+            try {
+                await this.pluginLoader.callHook(instance.plugin, 'destroy', instance.context);
+            }
+            catch (error) {
+                logger.error('PluginRegistryService', `Error destroying plugin ${pluginId}:`, error);
+            }
+        }
+        // Remove from registry
+        this.plugins.delete(pluginId);
+        logger.info('PluginRegistryService', `Unloaded plugin: ${pluginId}`);
+    }
+    /**
+     * Enable a plugin
+     */
+    async enablePlugin(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not loaded`);
+        }
+        if (instance.enabled) {
+            logger.debug('PluginRegistryService', `Plugin ${pluginId} is already enabled`);
+            return;
+        }
+        // Call enable hook
+        if (instance.plugin.enable) {
+            await this.pluginLoader.callHook(instance.plugin, 'enable', instance.context);
+        }
+        instance.enabled = true;
+        instance.config.enabled = true;
+        this.savePluginState();
+        logger.info('PluginRegistryService', `Enabled plugin: ${pluginId}`);
+    }
+    /**
+     * Disable a plugin
+     */
+    async disablePlugin(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not loaded`);
+        }
+        if (!instance.enabled) {
+            logger.debug('PluginRegistryService', `Plugin ${pluginId} is already disabled`);
+            return;
+        }
+        // Call disable hook
+        if (instance.plugin.disable) {
+            await this.pluginLoader.callHook(instance.plugin, 'disable', instance.context);
+        }
+        instance.enabled = false;
+        instance.config.enabled = false;
+        this.savePluginState();
+        logger.info('PluginRegistryService', `Disabled plugin: ${pluginId}`);
+    }
+    /**
+     * Get a plugin instance
+     */
+    getPlugin(pluginId) {
+        return this.plugins.get(pluginId);
+    }
+    /**
+     * Get all plugins
+     */
+    getAllPlugins() {
+        return [...this.plugins.values()];
+    }
+    /**
+     * Get enabled plugins
+     */
+    getEnabledPlugins() {
+        return this.getAllPlugins().filter(p => p.enabled);
+    }
+    /**
+     * Check if a plugin is loaded
+     */
+    isLoaded(pluginId) {
+        return this.plugins.has(pluginId);
+    }
+    /**
+     * Check if a plugin is enabled
+     */
+    isEnabled(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        return plugin?.enabled ?? false;
+    }
+    /**
+     * Get plugin permissions
+     */
+    getPermissions(pluginId) {
+        return this.permissionsService.getPermissions(pluginId);
+    }
+    /**
+     * Load all plugins from the plugins directory
+     */
+    async loadAllPlugins() {
+        if (!existsSync(PLUGINS_DIR)) {
+            logger.info('PluginRegistryService', 'Plugins directory does not exist, skipping plugin loading');
+            return;
+        }
+        const entries = readdirSync(PLUGINS_DIR, { withFileTypes: true });
+        const pluginDirs = entries
+            .filter(entry => entry.isDirectory())
+            .map(entry => join(PLUGINS_DIR, entry.name));
+        logger.info('PluginRegistryService', `Found ${pluginDirs.length} potential plugin(s)`);
+        for (const pluginDir of pluginDirs) {
+            try {
+                const instance = await this.loadPlugin(pluginDir);
+                // Check if plugin was previously enabled
+                const savedState = this.getSavedPluginState(instance.manifest.id);
+                if (savedState?.enabled) {
+                    await this.enablePlugin(instance.manifest.id);
+                }
+            }
+            catch (error) {
+                logger.error('PluginRegistryService', `Failed to load plugin from ${pluginDir}:`, error);
+            }
+        }
+        logger.info('PluginRegistryService', `Loaded ${this.plugins.size} plugin(s)`);
+    }
+    /**
+     * Save plugin enabled/disabled state to config
+     */
+    savePluginState() {
+        const pluginStates = {};
+        for (const [id, instance] of this.plugins) {
+            pluginStates[id] = { enabled: instance.enabled };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.configService.set('pluginStates', pluginStates);
+    }
+    /**
+     * Get saved plugin state from config
+     */
+    getSavedPluginState(pluginId) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const states = this.configService.get('pluginStates');
+        return states?.[pluginId];
+    }
+    /**
+     * Clear all plugins
+     */
+    async unloadAllPlugins() {
+        const pluginIds = [...this.plugins.keys()];
+        for (const pluginId of pluginIds) {
+            try {
+                await this.unloadPlugin(pluginId);
+            }
+            catch (error) {
+                logger.error('PluginRegistryService', `Error unloading plugin ${pluginId}:`, error);
+            }
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin registry service singleton
+ */
+export function getPluginRegistryService() {
+    if (!instance) {
+        instance = new PluginRegistryService();
+    }
+    return instance;
+}
+/**
+ * Reset the singleton (for testing)
+ */
+export function resetPluginRegistryService() {
+    if (instance) {
+        void instance.unloadAllPlugins();
+    }
+    instance = null;
+}

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

@@ -0,0 +1,25 @@
+import type { ReactElement } from 'react';
+/**
+ * Register a plugin view
+ */
+export declare function registerPluginView(viewId: string, component: ReactElement): void;
+/**
+ * Unregister a plugin view
+ */
+export declare function unregisterPluginView(viewId: string): void;
+/**
+ * Get a plugin view by ID
+ */
+export declare function getPluginView(viewId: string): ReactElement | undefined;
+/**
+ * Check if a plugin view exists
+ */
+export declare function hasPluginView(viewId: string): boolean;
+/**
+ * Get all registered plugin views
+ */
+export declare function getAllPluginViews(): Map<string, ReactElement>;
+/**
+ * Clear all plugin views (for cleanup)
+ */
+export declare function clearAllPluginViews(): void;

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

@@ -0,0 +1,46 @@
+import { logger } from "../logger/logger.service.js";
+// Registry for plugin views
+const pluginViews = new Map();
+/**
+ * Register a plugin view
+ */
+export function registerPluginView(viewId, component) {
+    if (pluginViews.has(viewId)) {
+        logger.warn('PluginUIAPI', `View ${viewId} is already registered`);
+        return;
+    }
+    pluginViews.set(viewId, component);
+    logger.info('PluginUIAPI', `Registered view: ${viewId}`);
+}
+/**
+ * Unregister a plugin view
+ */
+export function unregisterPluginView(viewId) {
+    pluginViews.delete(viewId);
+    logger.info('PluginUIAPI', `Unregistered view: ${viewId}`);
+}
+/**
+ * Get a plugin view by ID
+ */
+export function getPluginView(viewId) {
+    return pluginViews.get(viewId);
+}
+/**
+ * Check if a plugin view exists
+ */
+export function hasPluginView(viewId) {
+    return pluginViews.has(viewId);
+}
+/**
+ * Get all registered plugin views
+ */
+export function getAllPluginViews() {
+    return new Map(pluginViews);
+}
+/**
+ * Clear all plugin views (for cleanup)
+ */
+export function clearAllPluginViews() {
+    pluginViews.clear();
+    logger.info('PluginUIAPI', 'Cleared all plugin views');
+}

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

@@ -0,0 +1,23 @@
+import type { PluginUpdateResult } from '../../types/plugin.types.ts';
+/**
+ * Plugin updater service
+ */
+declare class PluginUpdaterService {
+    /**
+     * Check if updates are available for a plugin
+     */
+    checkForUpdates(pluginId: string): Promise<{
+        hasUpdate: boolean;
+        currentVersion?: string;
+        latestVersion?: string;
+    }>;
+    /**
+     * Update a plugin with smart merge (preserve user data)
+     */
+    updatePlugin(pluginId: string): Promise<PluginUpdateResult>;
+}
+/**
+ * Get the plugin updater service singleton
+ */
+export declare function getPluginUpdaterService(): PluginUpdaterService;
+export {};