sdd-mcp-server 1.0.0

package/dist/infrastructure/plugins/PluginManager.js

@@ -0,0 +1,650 @@
+// Plugin manager implementation for discovery, loading, and lifecycle management
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { EventEmitter } from 'events';
+import { TYPES } from '../di/types.js';
+import { createHash, randomBytes, createCipher, createDecipher } from 'crypto';
+const DEFAULT_CONFIG = {
+    pluginsDirectory: './plugins',
+    dataDirectory: './data/plugins',
+    maxPlugins: 100,
+    securityEnabled: true,
+    autoDiscovery: true,
+    autoLoad: false,
+    isolationMode: 'sandbox'
+};
+let PluginManager = class PluginManager {
+    logger;
+    fileSystem;
+    hookSystem;
+    toolRegistry;
+    steeringRegistry;
+    config;
+    plugins = new Map();
+    eventEmitter = new EventEmitter();
+    initialized = false;
+    constructor(logger, fileSystem, hookSystem, toolRegistry, steeringRegistry, config = {}) {
+        this.logger = logger;
+        this.fileSystem = fileSystem;
+        this.hookSystem = hookSystem;
+        this.toolRegistry = toolRegistry;
+        this.steeringRegistry = steeringRegistry;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            // Ensure plugin directories exist
+            await this.ensureDirectories();
+            // Auto-discovery if enabled
+            if (this.config.autoDiscovery) {
+                const discovered = await this.discover();
+                this.logger.info('Auto-discovery completed', {
+                    pluginsFound: discovered.length,
+                    validPlugins: discovered.filter(d => d.valid).length
+                });
+                // Auto-load valid plugins if enabled
+                if (this.config.autoLoad) {
+                    for (const descriptor of discovered.filter(d => d.valid)) {
+                        try {
+                            await this.install(descriptor.path);
+                            await this.load(descriptor.manifest.id);
+                            await this.enable(descriptor.manifest.id);
+                        }
+                        catch (error) {
+                            this.logger.warn('Failed to auto-load plugin', {
+                                pluginId: descriptor.manifest.id,
+                                error: error instanceof Error ? error.message : String(error)
+                            });
+                        }
+                    }
+                }
+            }
+            this.initialized = true;
+            this.logger.info('Plugin manager initialized', {
+                pluginsDirectory: this.config.pluginsDirectory,
+                loadedPlugins: this.plugins.size
+            });
+        }
+        catch (error) {
+            this.logger.error('Plugin manager initialization failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async discover(directory) {
+        const searchDirectory = directory || this.config.pluginsDirectory;
+        const descriptors = [];
+        try {
+            await fs.mkdir(searchDirectory, { recursive: true });
+            const entries = await fs.readdir(searchDirectory, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const pluginPath = path.join(searchDirectory, entry.name);
+                    const manifestPath = path.join(pluginPath, 'plugin.json');
+                    try {
+                        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+                        const manifest = JSON.parse(manifestContent);
+                        const validation = await this.validatePlugin(manifest);
+                        descriptors.push({
+                            path: pluginPath,
+                            manifest,
+                            valid: validation.valid,
+                            errors: validation.errors.map(e => e.message),
+                            warnings: validation.warnings.map(w => w.message)
+                        });
+                        this.logger.debug('Plugin discovered', {
+                            id: manifest.id,
+                            name: manifest.name,
+                            valid: validation.valid,
+                            path: pluginPath
+                        });
+                    }
+                    catch (error) {
+                        descriptors.push({
+                            path: pluginPath,
+                            manifest: {},
+                            valid: false,
+                            errors: [`Failed to read manifest: ${error instanceof Error ? error.message : String(error)}`],
+                            warnings: []
+                        });
+                    }
+                }
+            }
+            this.logger.info('Plugin discovery completed', {
+                directory: searchDirectory,
+                totalPlugins: descriptors.length,
+                validPlugins: descriptors.filter(d => d.valid).length
+            });
+            return descriptors;
+        }
+        catch (error) {
+            this.logger.error('Plugin discovery failed', {
+                directory: searchDirectory,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async install(pluginPath) {
+        const manifestPath = path.join(pluginPath, 'plugin.json');
+        try {
+            const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestContent);
+            // Validate plugin
+            const validation = await this.validatePlugin(manifest);
+            if (!validation.valid) {
+                throw new Error(`Plugin validation failed: ${validation.errors.map(e => e.message).join(', ')}`);
+            }
+            // Check for conflicts
+            if (this.plugins.has(manifest.id)) {
+                throw new Error(`Plugin ${manifest.id} is already installed`);
+            }
+            // Check capacity
+            if (this.plugins.size >= this.config.maxPlugins) {
+                throw new Error(`Maximum number of plugins (${this.config.maxPlugins}) reached`);
+            }
+            // Resolve dependencies
+            const dependencies = await this.resolveDependencies(manifest);
+            this.logger.debug('Plugin dependencies resolved', {
+                pluginId: manifest.id,
+                dependencies: dependencies.length
+            });
+            // Create plugin context
+            const context = await this.createPluginContext(manifest, pluginPath);
+            // Load plugin implementation
+            const implementation = await this.loadPluginImplementation(pluginPath, context);
+            // Create plugin instance
+            const instance = {
+                plugin: manifest,
+                instance: implementation,
+                state: PluginState.INSTALLED,
+                loadedAt: new Date(),
+                configuration: { ...manifest.configuration.defaults },
+                hooks: [],
+                tools: []
+            };
+            this.plugins.set(manifest.id, instance);
+            this.eventEmitter.emit('plugin-installed', { pluginId: manifest.id, instance });
+            this.logger.info('Plugin installed successfully', {
+                id: manifest.id,
+                name: manifest.name,
+                version: manifest.version
+            });
+            return instance;
+        }
+        catch (error) {
+            this.logger.error('Plugin installation failed', {
+                pluginPath,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async uninstall(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not installed`);
+        }
+        try {
+            // Disable plugin if active
+            if (instance.state === PluginState.ACTIVE) {
+                await this.disable(pluginId);
+            }
+            // Unload plugin if loaded
+            if (instance.state === PluginState.LOADED) {
+                await this.unload(pluginId);
+            }
+            // Clear all plugin registrations (defensive cleanup)
+            await this.hookSystem.clearHooks(pluginId);
+            await this.toolRegistry.clearTools(pluginId);
+            await this.steeringRegistry.clearSteeringDocuments(pluginId);
+            // Dispose plugin resources
+            await instance.instance.dispose();
+            // Remove from registry
+            this.plugins.delete(pluginId);
+            this.eventEmitter.emit('plugin-uninstalled', { pluginId });
+            this.logger.info('Plugin uninstalled successfully', { pluginId });
+        }
+        catch (error) {
+            this.logger.error('Plugin uninstallation failed', {
+                pluginId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async enable(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not installed`);
+        }
+        if (instance.state === PluginState.ACTIVE) {
+            this.logger.debug('Plugin is already enabled', { pluginId });
+            return;
+        }
+        try {
+            instance.state = PluginState.LOADING;
+            // Initialize plugin if not already done
+            if (instance.state !== PluginState.LOADED) {
+                await instance.instance.initialize(await this.createPluginContext(instance.plugin, ''));
+            }
+            // Register plugin hooks
+            for (const hookDeclaration of instance.plugin.hooks) {
+                const hookRegistration = {
+                    pluginId,
+                    name: hookDeclaration.name,
+                    type: hookDeclaration.type,
+                    phase: hookDeclaration.phase,
+                    priority: hookDeclaration.priority,
+                    handler: async (context) => {
+                        return await instance.instance.executeHook(hookDeclaration.name, context);
+                    },
+                    conditions: []
+                };
+                await this.hookSystem.register(pluginId, hookRegistration);
+            }
+            // Register plugin tools
+            for (const toolDeclaration of instance.plugin.tools) {
+                const toolRegistration = {
+                    pluginId,
+                    name: toolDeclaration.name,
+                    description: toolDeclaration.description,
+                    category: toolDeclaration.category,
+                    handler: async (input, context) => {
+                        return await instance.instance.executeTool(toolDeclaration.name, input);
+                    },
+                    inputSchema: toolDeclaration.inputSchema,
+                    outputSchema: toolDeclaration.outputSchema,
+                    permissions: toolDeclaration.permissions
+                };
+                await this.toolRegistry.register(pluginId, toolRegistration);
+            }
+            // Register plugin steering documents
+            for (const steeringDeclaration of instance.plugin.steeringDocuments) {
+                await this.steeringRegistry.registerSteeringDocument(pluginId, steeringDeclaration);
+            }
+            // Activate plugin
+            await instance.instance.activate();
+            instance.state = PluginState.ACTIVE;
+            this.eventEmitter.emit('plugin-enabled', { pluginId, instance });
+            this.logger.info('Plugin enabled successfully', {
+                pluginId,
+                hooks: instance.plugin.hooks.length,
+                tools: instance.plugin.tools.length,
+                steeringDocuments: instance.plugin.steeringDocuments.length
+            });
+        }
+        catch (error) {
+            instance.state = PluginState.ERROR;
+            instance.lastError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Plugin enable failed', {
+                pluginId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async disable(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not installed`);
+        }
+        if (instance.state !== PluginState.ACTIVE) {
+            this.logger.debug('Plugin is not active', { pluginId, state: instance.state });
+            return;
+        }
+        try {
+            // Deactivate plugin first
+            await instance.instance.deactivate();
+            // Unregister plugin hooks
+            for (const hookDeclaration of instance.plugin.hooks) {
+                await this.hookSystem.unregister(pluginId, hookDeclaration.name);
+            }
+            // Unregister plugin tools
+            for (const toolDeclaration of instance.plugin.tools) {
+                await this.toolRegistry.unregister(pluginId, toolDeclaration.name);
+            }
+            // Unregister plugin steering documents
+            for (const steeringDeclaration of instance.plugin.steeringDocuments) {
+                await this.steeringRegistry.unregisterSteeringDocument(pluginId, steeringDeclaration.name);
+            }
+            instance.state = PluginState.INACTIVE;
+            this.eventEmitter.emit('plugin-disabled', { pluginId, instance });
+            this.logger.info('Plugin disabled successfully', {
+                pluginId,
+                hooks: instance.plugin.hooks.length,
+                tools: instance.plugin.tools.length,
+                steeringDocuments: instance.plugin.steeringDocuments.length
+            });
+        }
+        catch (error) {
+            instance.state = PluginState.ERROR;
+            instance.lastError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Plugin disable failed', {
+                pluginId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async load(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not installed`);
+        }
+        if (instance.state === PluginState.LOADED || instance.state === PluginState.ACTIVE) {
+            return instance;
+        }
+        try {
+            instance.state = PluginState.LOADING;
+            const context = await this.createPluginContext(instance.plugin, '');
+            await instance.instance.initialize(context);
+            instance.state = PluginState.LOADED;
+            this.eventEmitter.emit('plugin-loaded', { pluginId, instance });
+            this.logger.info('Plugin loaded successfully', { pluginId });
+            return instance;
+        }
+        catch (error) {
+            instance.state = PluginState.ERROR;
+            instance.lastError = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Plugin load failed', {
+                pluginId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async unload(pluginId) {
+        const instance = this.plugins.get(pluginId);
+        if (!instance) {
+            throw new Error(`Plugin ${pluginId} is not installed`);
+        }
+        try {
+            if (instance.state === PluginState.ACTIVE) {
+                await this.disable(pluginId);
+            }
+            await instance.instance.dispose();
+            instance.state = PluginState.INSTALLED;
+            this.eventEmitter.emit('plugin-unloaded', { pluginId, instance });
+            this.logger.info('Plugin unloaded successfully', { pluginId });
+        }
+        catch (error) {
+            this.logger.error('Plugin unload failed', {
+                pluginId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async getPlugin(pluginId) {
+        return this.plugins.get(pluginId) || null;
+    }
+    async getAllPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    async getEnabledPlugins() {
+        return Array.from(this.plugins.values()).filter(p => p.state === PluginState.ACTIVE);
+    }
+    async validatePlugin(plugin) {
+        const errors = [];
+        const warnings = [];
+        const securityIssues = [];
+        const compatibilityIssues = [];
+        // Basic validation
+        if (!plugin.id) {
+            errors.push({
+                type: 'missing-field',
+                message: 'Plugin ID is required',
+                field: 'id',
+                severity: ValidationSeverity.CRITICAL
+            });
+        }
+        if (!plugin.name) {
+            errors.push({
+                type: 'missing-field',
+                message: 'Plugin name is required',
+                field: 'name',
+                severity: ValidationSeverity.HIGH
+            });
+        }
+        if (!plugin.version) {
+            errors.push({
+                type: 'missing-field',
+                message: 'Plugin version is required',
+                field: 'version',
+                severity: ValidationSeverity.HIGH
+            });
+        }
+        // Security validation
+        if (this.config.securityEnabled) {
+            const security = await this.performSecurityValidation(plugin);
+            securityIssues.push(...security);
+        }
+        // Compatibility validation
+        const compatibility = await this.performCompatibilityValidation(plugin);
+        compatibilityIssues.push(...compatibility);
+        return {
+            valid: errors.filter(e => e.severity === ValidationSeverity.CRITICAL).length === 0,
+            errors,
+            warnings,
+            securityIssues,
+            compatibilityIssues
+        };
+    }
+    async resolveDependencies(plugin) {
+        const resolved = [];
+        for (const dep of plugin.dependencies) {
+            // Check if dependency is already installed
+            const installedPlugin = this.plugins.get(dep.name);
+            if (installedPlugin) {
+                // Version compatibility check would go here
+                resolved.push(dep);
+            }
+            else if (!dep.optional) {
+                throw new Error(`Required dependency ${dep.name} is not installed`);
+            }
+        }
+        return resolved;
+    }
+    // Private helper methods
+    async ensureDirectories() {
+        await fs.mkdir(this.config.pluginsDirectory, { recursive: true });
+        await fs.mkdir(this.config.dataDirectory, { recursive: true });
+    }
+    async createPluginContext(plugin, pluginPath) {
+        const dataDirectory = path.join(this.config.dataDirectory, plugin.id);
+        await fs.mkdir(dataDirectory, { recursive: true });
+        return {
+            pluginId: plugin.id,
+            workingDirectory: pluginPath,
+            configurationDirectory: path.join(dataDirectory, 'config'),
+            dataDirectory,
+            logger: this.createPluginLogger(plugin.id),
+            services: this.createPluginServices(plugin.id),
+            events: this.createPluginEventEmitter(plugin.id)
+        };
+    }
+    async loadPluginImplementation(pluginPath, context) {
+        const indexPath = path.join(pluginPath, 'index.js');
+        try {
+            // In a production environment, this would use a more secure module loading system
+            const pluginModule = await import(`file://${indexPath}`);
+            if (!pluginModule.default) {
+                throw new Error('Plugin must export a default class implementing PluginImplementation');
+            }
+            const PluginClass = pluginModule.default;
+            return new PluginClass();
+        }
+        catch (error) {
+            throw new Error(`Failed to load plugin implementation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    createPluginLogger(pluginId) {
+        return {
+            debug: (message, data) => {
+                this.logger.debug(`[${pluginId}] ${message}`, data);
+            },
+            info: (message, data) => {
+                this.logger.info(`[${pluginId}] ${message}`, data);
+            },
+            warn: (message, data) => {
+                this.logger.warn(`[${pluginId}] ${message}`, data);
+            },
+            error: (message, error, data) => {
+                this.logger.error(`[${pluginId}] ${message}`, { error, ...data });
+            }
+        };
+    }
+    createPluginServices(pluginId) {
+        return {
+            fileSystem: this.createPluginFileSystem(pluginId),
+            http: this.createPluginHttpClient(pluginId),
+            crypto: this.createPluginCrypto(pluginId),
+            utils: this.createPluginUtils(pluginId)
+        };
+    }
+    createPluginEventEmitter(pluginId) {
+        const emitter = new EventEmitter();
+        return {
+            on: (event, listener) => {
+                emitter.on(event, listener);
+            },
+            off: (event, listener) => {
+                emitter.off(event, listener);
+            },
+            emit: (event, ...args) => {
+                emitter.emit(event, ...args);
+            }
+        };
+    }
+    createPluginFileSystem(pluginId) {
+        // This would include security restrictions for plugin file access
+        return {
+            readFile: async (path) => this.fileSystem.readFile(path),
+            writeFile: async (path, content) => this.fileSystem.writeFile(path, content),
+            exists: async (path) => this.fileSystem.exists(path),
+            mkdir: async (path) => this.fileSystem.mkdir(path),
+            readdir: async (path) => [], // Simplified
+            stat: async (path) => ({ size: 0, mtime: new Date(), isFile: () => true, isDirectory: () => false })
+        };
+    }
+    createPluginHttpClient(pluginId) {
+        // Simplified HTTP client implementation
+        return {
+            get: async () => ({ status: 200, statusText: 'OK', headers: {}, data: {} }),
+            post: async () => ({ status: 200, statusText: 'OK', headers: {}, data: {} }),
+            put: async () => ({ status: 200, statusText: 'OK', headers: {}, data: {} }),
+            delete: async () => ({ status: 200, statusText: 'OK', headers: {}, data: {} })
+        };
+    }
+    createPluginCrypto(pluginId) {
+        return {
+            hash: (data, algorithm = 'sha256') => createHash(algorithm).update(data).digest('hex'),
+            encrypt: (data, key) => {
+                const cipher = createCipher('aes192', key);
+                let encrypted = cipher.update(data, 'utf8', 'hex');
+                encrypted += cipher.final('hex');
+                return encrypted;
+            },
+            decrypt: (data, key) => {
+                const decipher = createDecipher('aes192', key);
+                let decrypted = decipher.update(data, 'hex', 'utf8');
+                decrypted += decipher.final('utf8');
+                return decrypted;
+            },
+            generateId: () => randomBytes(16).toString('hex'),
+            generateSecret: (length = 32) => randomBytes(length).toString('hex')
+        };
+    }
+    createPluginUtils(pluginId) {
+        return {
+            validateSchema: () => ({ valid: true, errors: [], warnings: [] }),
+            formatDate: (date, format) => date.toISOString(),
+            parseTemplate: (template, data) => template,
+            debounce: (fn, delay) => {
+                let timeoutId;
+                return ((...args) => {
+                    clearTimeout(timeoutId);
+                    timeoutId = setTimeout(() => fn(...args), delay);
+                });
+            },
+            throttle: (fn, interval) => {
+                let lastCall = 0;
+                return ((...args) => {
+                    const now = Date.now();
+                    if (now - lastCall >= interval) {
+                        lastCall = now;
+                        return fn(...args);
+                    }
+                });
+            }
+        };
+    }
+    async performSecurityValidation(plugin) {
+        const issues = [];
+        // Check for dangerous permissions
+        const dangerousPermissions = ['file:execute', 'system:info'];
+        for (const tool of plugin.tools) {
+            for (const permission of tool.permissions) {
+                if (dangerousPermissions.includes(permission.type)) {
+                    issues.push({
+                        type: SecurityIssueType.PRIVILEGE_ESCALATION,
+                        severity: SecuritySeverity.HIGH,
+                        message: `Tool '${tool.name}' requests dangerous permission '${permission.type}'`,
+                        recommendation: 'Review if this permission is necessary and ensure proper validation'
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+    async performCompatibilityValidation(plugin) {
+        const issues = [];
+        // Check engine requirements
+        for (const engine of plugin.engines) {
+            if (engine.name === 'node' && engine.version) {
+                const currentNodeVersion = process.version;
+                if (!this.isVersionCompatible(currentNodeVersion, engine.version)) {
+                    issues.push({
+                        type: 'engine-incompatible',
+                        message: `Plugin requires Node.js ${engine.version}, but current version is ${currentNodeVersion}`,
+                        affectedVersions: [currentNodeVersion],
+                        workaround: `Upgrade Node.js to ${engine.version} or later`
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+    isVersionCompatible(current, required) {
+        // Simplified version comparison - would use proper semver in production
+        return current >= required;
+    }
+};
+PluginManager = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.LoggerPort)),
+    __param(1, inject(TYPES.FileSystemPort)),
+    __param(2, inject(TYPES.HookSystem)),
+    __param(3, inject(TYPES.PluginToolRegistry)),
+    __param(4, inject(TYPES.PluginSteeringRegistry)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Function, Object])
+], PluginManager);
+export { PluginManager };
+//# sourceMappingURL=PluginManager.js.map