@involvex/youtube-music-cli 0.0.47 → 0.0.48

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

@@ -1,248 +0,0 @@
-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,
-                });
-            }
-            // Plugin is at root of repo (e.g., adblock/, lyrics/, etc.)
-            const pluginSourceDir = join(tempDir, 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.js

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

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