@involvex/youtube-music-cli 0.0.0

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

@@ -0,0 +1,247 @@
+import { CONFIG_DIR } from "../../utils/constants.js";
+import { logger } from "../logger/logger.service.js";
+import { join } from 'node:path';
+import { existsSync, mkdirSync, rmSync, cpSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+const PLUGINS_DIR = join(CONFIG_DIR, 'plugins');
+const DEFAULT_PLUGIN_REPO = 'https://github.com/involvex/youtube-music-cli-plugins';
+/**
+ * Plugin installer service
+ */
+class PluginInstallerService {
+    /**
+     * Install a plugin from GitHub repository
+     */
+    async installFromGitHub(repoUrl, pluginName) {
+        try {
+            logger.info('PluginInstallerService', `Installing from ${repoUrl}`);
+            // Ensure plugins directory exists
+            if (!existsSync(PLUGINS_DIR)) {
+                mkdirSync(PLUGINS_DIR, { recursive: true });
+            }
+            // Determine plugin name from URL if not provided
+            if (!pluginName) {
+                const match = repoUrl.match(/\/([^/]+?)(\.git)?$/);
+                pluginName = match?.[1] || 'unknown-plugin';
+            }
+            const targetDir = join(PLUGINS_DIR, pluginName);
+            // Check if plugin already exists
+            if (existsSync(targetDir)) {
+                return {
+                    success: false,
+                    error: `Plugin ${pluginName} is already installed`,
+                };
+            }
+            // Clone repository
+            try {
+                execSync(`git clone "${repoUrl}" "${targetDir}"`, {
+                    stdio: 'pipe',
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                logger.error('PluginInstallerService', 'Git clone failed:', error);
+                return {
+                    success: false,
+                    error: `Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+            // Validate plugin structure
+            const manifestPath = join(targetDir, 'plugin.json');
+            if (!existsSync(manifestPath)) {
+                // Cleanup
+                rmSync(targetDir, { recursive: true, force: true });
+                return {
+                    success: false,
+                    error: 'Invalid plugin: plugin.json not found',
+                };
+            }
+            // Check for npm dependencies
+            const packageJsonPath = join(targetDir, 'package.json');
+            if (existsSync(packageJsonPath)) {
+                logger.info('PluginInstallerService', 'Installing plugin dependencies...');
+                try {
+                    execSync('bun install', {
+                        cwd: targetDir,
+                        stdio: 'pipe',
+                        windowsHide: true,
+                    });
+                }
+                catch (error) {
+                    logger.error('PluginInstallerService', 'Failed to install dependencies:', error);
+                    // Continue anyway - plugin might still work
+                }
+            }
+            logger.info('PluginInstallerService', `Successfully installed plugin: ${pluginName}`);
+            return {
+                success: true,
+                pluginId: pluginName,
+                message: `Plugin ${pluginName} installed successfully`,
+            };
+        }
+        catch (error) {
+            logger.error('PluginInstallerService', 'Install failed:', error);
+            return {
+                success: false,
+                error: `Installation failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Install a plugin from the default plugin repository
+     */
+    async installFromDefaultRepo(pluginName) {
+        logger.info('PluginInstallerService', `Installing ${pluginName} from default repo`);
+        // For now, use sparse checkout or clone entire repo and copy plugin
+        // Simplified: clone entire repo to temp, copy plugin, delete temp
+        try {
+            const tempDir = join(PLUGINS_DIR, '.temp-install');
+            // Clone default repo
+            if (!existsSync(tempDir)) {
+                execSync(`git clone "${DEFAULT_PLUGIN_REPO}" "${tempDir}"`, {
+                    stdio: 'pipe',
+                    windowsHide: true,
+                });
+            }
+            else {
+                // Pull latest
+                execSync('git pull', {
+                    cwd: tempDir,
+                    stdio: 'pipe',
+                    windowsHide: true,
+                });
+            }
+            const pluginSourceDir = join(tempDir, 'plugins', pluginName);
+            if (!existsSync(pluginSourceDir)) {
+                rmSync(tempDir, { recursive: true, force: true });
+                return {
+                    success: false,
+                    error: `Plugin ${pluginName} not found in default repository`,
+                };
+            }
+            const targetDir = join(PLUGINS_DIR, pluginName);
+            if (existsSync(targetDir)) {
+                rmSync(tempDir, { recursive: true, force: true });
+                return {
+                    success: false,
+                    error: `Plugin ${pluginName} is already installed`,
+                };
+            }
+            // Copy plugin to plugins directory
+            cpSync(pluginSourceDir, targetDir, { recursive: true });
+            // Cleanup temp directory
+            rmSync(tempDir, { recursive: true, force: true });
+            // Install dependencies if needed
+            const packageJsonPath = join(targetDir, 'package.json');
+            if (existsSync(packageJsonPath)) {
+                try {
+                    execSync('bun install', {
+                        cwd: targetDir,
+                        stdio: 'pipe',
+                        windowsHide: true,
+                    });
+                }
+                catch (error) {
+                    logger.warn('PluginInstallerService', 'Failed to install dependencies:', error);
+                }
+            }
+            return {
+                success: true,
+                pluginId: pluginName,
+                message: `Plugin ${pluginName} installed successfully`,
+            };
+        }
+        catch (error) {
+            logger.error('PluginInstallerService', 'Install failed:', error);
+            return {
+                success: false,
+                error: `Installation failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Install a plugin from local directory (for development)
+     */
+    async installFromLocal(sourcePath) {
+        try {
+            if (!existsSync(sourcePath)) {
+                return {
+                    success: false,
+                    error: `Source path does not exist: ${sourcePath}`,
+                };
+            }
+            const manifestPath = join(sourcePath, 'plugin.json');
+            if (!existsSync(manifestPath)) {
+                return {
+                    success: false,
+                    error: 'Invalid plugin: plugin.json not found',
+                };
+            }
+            // Read manifest to get plugin ID
+            const { readFileSync: fsReadFileSync } = await import('node:fs');
+            const manifest = JSON.parse(fsReadFileSync(manifestPath, 'utf-8'));
+            const targetDir = join(PLUGINS_DIR, manifest.id);
+            if (existsSync(targetDir)) {
+                return {
+                    success: false,
+                    error: `Plugin ${manifest.id} is already installed`,
+                };
+            }
+            // Copy to plugins directory
+            if (!existsSync(PLUGINS_DIR)) {
+                mkdirSync(PLUGINS_DIR, { recursive: true });
+            }
+            cpSync(sourcePath, targetDir, { recursive: true });
+            return {
+                success: true,
+                pluginId: manifest.id,
+                message: `Plugin ${manifest.name} installed from local path`,
+            };
+        }
+        catch (error) {
+            logger.error('PluginInstallerService', 'Install failed:', error);
+            return {
+                success: false,
+                error: `Installation failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Uninstall a plugin
+     */
+    async uninstall(pluginId) {
+        const pluginDir = join(PLUGINS_DIR, pluginId);
+        if (!existsSync(pluginDir)) {
+            return {
+                success: false,
+                error: `Plugin ${pluginId} is not installed`,
+            };
+        }
+        try {
+            rmSync(pluginDir, { recursive: true, force: true });
+            return {
+                success: true,
+                pluginId,
+                message: `Plugin ${pluginId} uninstalled successfully`,
+            };
+        }
+        catch (error) {
+            logger.error('PluginInstallerService', 'Uninstall failed:', error);
+            return {
+                success: false,
+                error: `Uninstall failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin installer service singleton
+ */
+export function getPluginInstallerService() {
+    if (!instance) {
+        instance = new PluginInstallerService();
+    }
+    return instance;
+}

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

@@ -0,0 +1,33 @@
+import type { Plugin, PluginInstance } from '../../types/plugin.types.ts';
+/**
+ * Plugin loader service - handles dynamic loading of plugins
+ */
+declare class PluginLoaderService {
+    private jiti;
+    constructor();
+    /**
+     * Load a plugin from a directory
+     */
+    loadPlugin(pluginPath: string): Promise<PluginInstance>;
+    /**
+     * Validate plugin module structure
+     */
+    private isValidPlugin;
+    /**
+     * Call plugin lifecycle hook safely
+     */
+    callHook(plugin: Plugin, hook: 'init' | 'enable' | 'disable' | 'destroy', context: PluginInstance['context']): Promise<void>;
+    /**
+     * Reload a plugin (useful for development)
+     */
+    reloadPlugin(pluginPath: string): Promise<PluginInstance>;
+}
+/**
+ * Get the plugin loader service singleton
+ */
+export declare function getPluginLoaderService(): PluginLoaderService;
+/**
+ * Reset the singleton (for testing)
+ */
+export declare function resetPluginLoaderService(): void;
+export {};

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

@@ -0,0 +1,161 @@
+import { logger } from "../logger/logger.service.js";
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createJiti } from 'jiti';
+/**
+ * Validate plugin manifest
+ */
+function validateManifest(manifest) {
+    if (typeof manifest !== 'object' || manifest === null) {
+        return false;
+    }
+    const m = manifest;
+    return (typeof m['id'] === 'string' &&
+        typeof m['name'] === 'string' &&
+        typeof m['version'] === 'string' &&
+        typeof m['description'] === 'string' &&
+        typeof m['author'] === 'string' &&
+        typeof m['main'] === 'string' &&
+        Array.isArray(m['permissions']));
+}
+/**
+ * Plugin loader service - handles dynamic loading of plugins
+ */
+class PluginLoaderService {
+    jiti;
+    constructor() {
+        // Initialize jiti for dynamic TypeScript loading
+        this.jiti = createJiti(import.meta.url, {
+            interopDefault: true,
+            requireCache: false,
+        });
+    }
+    /**
+     * Load a plugin from a directory
+     */
+    async loadPlugin(pluginPath) {
+        logger.info('PluginLoaderService', `Loading plugin from ${pluginPath}`);
+        // Load and validate manifest
+        const manifestPath = join(pluginPath, 'plugin.json');
+        if (!existsSync(manifestPath)) {
+            throw new Error(`Plugin manifest not found: ${manifestPath}`);
+        }
+        const manifestData = readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(manifestData);
+        if (!validateManifest(manifest)) {
+            throw new Error(`Invalid plugin manifest: ${manifestPath}`);
+        }
+        logger.debug('PluginLoaderService', `Validated manifest for ${manifest.name} v${manifest.version}`);
+        // Load plugin module
+        const pluginEntryPath = join(pluginPath, manifest.main);
+        if (!existsSync(pluginEntryPath)) {
+            throw new Error(`Plugin entry point not found: ${pluginEntryPath}`);
+        }
+        let pluginModule;
+        try {
+            // Use jiti to load TypeScript/JavaScript module
+            pluginModule = await this.jiti.import(pluginEntryPath);
+        }
+        catch (error) {
+            logger.error('PluginLoaderService', `Failed to load plugin module:`, error);
+            throw new Error(`Failed to load plugin from ${pluginEntryPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Validate plugin module
+        if (!this.isValidPlugin(pluginModule)) {
+            throw new Error(`Invalid plugin module: ${pluginEntryPath}`);
+        }
+        const plugin = pluginModule;
+        // Verify manifest consistency
+        if (plugin.manifest.id !== manifest.id) {
+            logger.warn('PluginLoaderService', `Plugin manifest ID mismatch: ${plugin.manifest.id} vs ${manifest.id}`);
+        }
+        logger.info('PluginLoaderService', `Successfully loaded plugin: ${manifest.name} v${manifest.version}`);
+        // Create plugin instance (context will be injected later)
+        const instance = {
+            manifest,
+            plugin,
+            // Note: Context is set by plugin registry
+            context: null,
+            config: {
+                enabled: false,
+                config: {},
+                permissions: {},
+            },
+            enabled: false,
+            loadedAt: Date.now(),
+        };
+        return instance;
+    }
+    /**
+     * Validate plugin module structure
+     */
+    isValidPlugin(module) {
+        if (typeof module !== 'object' || module === null) {
+            return false;
+        }
+        const m = module;
+        // Must have manifest
+        if (!m['manifest'] || typeof m['manifest'] !== 'object') {
+            return false;
+        }
+        // Optional lifecycle hooks must be functions if present
+        if (m['init'] && typeof m['init'] !== 'function') {
+            return false;
+        }
+        if (m['enable'] && typeof m['enable'] !== 'function') {
+            return false;
+        }
+        if (m['disable'] && typeof m['disable'] !== 'function') {
+            return false;
+        }
+        if (m['destroy'] && typeof m['destroy'] !== 'function') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Call plugin lifecycle hook safely
+     */
+    async callHook(plugin, hook, context) {
+        const hookFn = plugin[hook];
+        if (!hookFn) {
+            logger.debug('PluginLoaderService', `Plugin ${plugin.manifest.name} has no ${hook} hook`);
+            return;
+        }
+        try {
+            logger.debug('PluginLoaderService', `Calling ${hook} hook for ${plugin.manifest.name}`);
+            await Promise.resolve(hookFn(context));
+            logger.debug('PluginLoaderService', `${hook} hook completed for ${plugin.manifest.name}`);
+        }
+        catch (error) {
+            logger.error('PluginLoaderService', `Error in ${hook} hook for ${plugin.manifest.name}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Reload a plugin (useful for development)
+     */
+    async reloadPlugin(pluginPath) {
+        logger.info('PluginLoaderService', `Reloading plugin from ${pluginPath}`);
+        // Clear jiti cache for this plugin
+        // Note: jiti has requireCache: false, so this should work automatically
+        return this.loadPlugin(pluginPath);
+    }
+}
+// Singleton instance
+let instance = null;
+/**
+ * Get the plugin loader service singleton
+ */
+export function getPluginLoaderService() {
+    if (!instance) {
+        instance = new PluginLoaderService();
+    }
+    return instance;
+}
+/**
+ * Reset the singleton (for testing)
+ */
+export function resetPluginLoaderService() {
+    instance = null;
+}

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

@@ -0,0 +1,72 @@
+import type { PluginPermission, PluginPermissions, PermissionStatus } from '../../types/plugin.types.ts';
+/**
+ * Plugin permissions service - manages permission grants and denials
+ */
+declare class PluginPermissionsService {
+    private permissions;
+    private permissionsPath;
+    private configDir;
+    onPermissionRequest?: (pluginId: string, permission: PluginPermission) => Promise<boolean>;
+    constructor();
+    /**
+     * Load permissions from disk
+     */
+    private load;
+    /**
+     * Save permissions to disk
+     */
+    private save;
+    /**
+     * Check if a plugin has a specific permission
+     */
+    hasPermission(pluginId: string, permission: PluginPermission): boolean;
+    /**
+     * Get permission status
+     */
+    getPermissionStatus(pluginId: string, permission: PluginPermission): PermissionStatus;
+    /**
+     * Get all permissions for a plugin
+     */
+    getPermissions(pluginId: string): PluginPermissions;
+    /**
+     * Grant a permission to a plugin
+     */
+    grantPermission(pluginId: string, permission: PluginPermission): void;
+    /**
+     * Deny a permission to a plugin
+     */
+    denyPermission(pluginId: string, permission: PluginPermission): void;
+    /**
+     * Request permission from user
+     */
+    requestPermission(pluginId: string, permission: PluginPermission): Promise<boolean>;
+    /**
+     * Grant multiple permissions at once
+     */
+    grantPermissions(pluginId: string, permissions: PluginPermission[]): void;
+    /**
+     * Revoke a permission
+     */
+    revokePermission(pluginId: string, permission: PluginPermission): void;
+    /**
+     * Revoke all permissions for a plugin
+     */
+    revokeAllPermissions(pluginId: string): void;
+    /**
+     * Get all plugin IDs with permissions
+     */
+    getAllPluginIds(): string[];
+    /**
+     * Reset all permissions (for testing or user request)
+     */
+    resetAll(): void;
+}
+/**
+ * Get the plugin permissions service singleton
+ */
+export declare function getPluginPermissionsService(): PluginPermissionsService;
+/**
+ * Reset the singleton (for testing)
+ */
+export declare function resetPluginPermissionsService(): void;
+export {};