@burdenoff/vibe-agent 1.0.1 → 1.0.2

package/dist/services/ModuleRegistryService.js

@@ -1,8 +1,8 @@
-import { EventEmitter } from 'events';
-import { spawn } from 'child_process';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import { EventEmitter } from "events";
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export class ModuleRegistryService extends EventEmitter {
     activeModules = new Map();
@@ -20,7 +20,7 @@ export class ModuleRegistryService extends EventEmitter {
         try {
             // Validate module manifest
             if (!this.validateModule(moduleData)) {
-                return { success: false, message: 'Invalid module manifest' };
+                return { success: false, message: "Invalid module manifest" };
             }
             // Check for port conflicts
             const portConflict = this.checkPortConflicts(moduleData);
@@ -32,28 +32,31 @@ export class ModuleRegistryService extends EventEmitter {
                 ...moduleData,
                 registeredAt: new Date(),
                 lastHeartbeat: new Date(),
-                status: 'running'
+                status: "running",
             };
             // Store module
             this.activeModules.set(registeredModule.name, registeredModule);
             // Start health monitoring
             this.startHealthMonitoring(registeredModule.name);
             // Log activity
-            this.logActivity('register', registeredModule.name);
+            this.logActivity("register", registeredModule.name);
             // Emit event
-            this.emit('module:registered', registeredModule);
+            this.emit("module:registered", registeredModule);
             console.log(`Module ${registeredModule.name} registered successfully`);
-            return { success: true, message: 'Module registered successfully' };
+            return { success: true, message: "Module registered successfully" };
         }
         catch (error) {
-            console.error('Module registration failed:', error);
-            return { success: false, message: error instanceof Error ? error.message : 'Unknown error' };
+            console.error("Module registration failed:", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+            };
         }
     }
     async unregisterModule(moduleId) {
         const module = this.activeModules.get(moduleId);
         if (!module) {
-            return { success: false, message: 'Module not found' };
+            return { success: false, message: "Module not found" };
         }
         try {
             // Stop health monitoring
@@ -63,80 +66,89 @@ export class ModuleRegistryService extends EventEmitter {
             // Remove from active modules
             this.activeModules.delete(moduleId);
             // Log activity
-            this.logActivity('unregister', moduleId);
+            this.logActivity("unregister", moduleId);
             // Emit event
-            this.emit('module:unregistered', module);
+            this.emit("module:unregistered", module);
             console.log(`Module ${moduleId} unregistered successfully`);
-            return { success: true, message: 'Module unregistered successfully' };
+            return { success: true, message: "Module unregistered successfully" };
         }
         catch (error) {
-            console.error('Module unregistration failed:', error);
-            return { success: false, message: error instanceof Error ? error.message : 'Unknown error' };
+            console.error("Module unregistration failed:", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+            };
         }
     }
     // Module lifecycle methods
     async activateModule(moduleId) {
         const module = this.activeModules.get(moduleId);
         if (!module) {
-            return { success: false, message: 'Module not found' };
+            return { success: false, message: "Module not found" };
         }
-        if (module.status === 'running') {
-            return { success: false, message: 'Module is already active' };
+        if (module.status === "running") {
+            return { success: false, message: "Module is already active" };
         }
         try {
             // Update status
-            module.status = 'starting';
+            module.status = "starting";
             this.activeModules.set(moduleId, module);
             // Start module processes
             await this.startModuleProcesses(module);
             // Update status
-            module.status = 'running';
+            module.status = "running";
             this.activeModules.set(moduleId, module);
             // Start health monitoring
             this.startHealthMonitoring(moduleId);
             // Log activity
-            this.logActivity('activate', moduleId);
+            this.logActivity("activate", moduleId);
             // Emit event
-            this.emit('module:activated', module);
-            return { success: true, message: 'Module activated successfully' };
+            this.emit("module:activated", module);
+            return { success: true, message: "Module activated successfully" };
         }
         catch (error) {
-            module.status = 'error';
+            module.status = "error";
             this.activeModules.set(moduleId, module);
-            console.error('Module activation failed:', error);
-            return { success: false, message: error instanceof Error ? error.message : 'Unknown error' };
+            console.error("Module activation failed:", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+            };
         }
     }
     async deactivateModule(moduleId) {
         const module = this.activeModules.get(moduleId);
         if (!module) {
-            return { success: false, message: 'Module not found' };
+            return { success: false, message: "Module not found" };
         }
-        if (module.status === 'stopped') {
-            return { success: false, message: 'Module is already inactive' };
+        if (module.status === "stopped") {
+            return { success: false, message: "Module is already inactive" };
         }
         try {
             // Update status
-            module.status = 'stopping';
+            module.status = "stopping";
             this.activeModules.set(moduleId, module);
             // Stop health monitoring
             this.stopHealthMonitoring(moduleId);
             // Stop module processes
             await this.stopModuleProcesses(moduleId);
             // Update status
-            module.status = 'stopped';
+            module.status = "stopped";
             this.activeModules.set(moduleId, module);
             // Log activity
-            this.logActivity('deactivate', moduleId);
+            this.logActivity("deactivate", moduleId);
             // Emit event
-            this.emit('module:deactivated', module);
-            return { success: true, message: 'Module deactivated successfully' };
+            this.emit("module:deactivated", module);
+            return { success: true, message: "Module deactivated successfully" };
         }
         catch (error) {
-            module.status = 'error';
+            module.status = "error";
             this.activeModules.set(moduleId, module);
-            console.error('Module deactivation failed:', error);
-            return { success: false, message: error instanceof Error ? error.message : 'Unknown error' };
+            console.error("Module deactivation failed:", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+            };
         }
     }
     // Module installation methods
@@ -145,46 +157,47 @@ export class ModuleRegistryService extends EventEmitter {
         const installation = {
             id: installationId,
             moduleId,
-            version: version || 'latest',
+            version: version || "latest",
             source,
             installedAt: new Date(),
-            status: 'pending',
+            status: "pending",
             progress: 0,
-            logs: []
+            logs: [],
         };
         this.installHistory.set(installationId, installation);
         try {
             // Update status
-            installation.status = 'downloading';
+            installation.status = "downloading";
             installation.progress = 10;
             this.installHistory.set(installationId, installation);
             // Download and install module based on source type
             switch (source.type) {
-                case 'remote':
+                case "remote":
                     await this.installFromRemote(installation);
                     break;
-                case 'marketplace':
+                case "marketplace":
                     await this.installFromMarketplace(installation);
                     break;
-                case 'container':
+                case "container":
                     await this.installFromContainer(installation);
                     break;
                 default:
                     throw new Error(`Unsupported source type: ${source.type}`);
             }
-            installation.status = 'installed';
+            installation.status = "installed";
             installation.progress = 100;
             this.installHistory.set(installationId, installation);
             // Log activity
-            this.logActivity('install', moduleId);
+            this.logActivity("install", moduleId);
             // Emit event
-            this.emit('module:installed', installation);
+            this.emit("module:installed", installation);
             console.log(`Module ${moduleId} installed successfully`);
         }
         catch (error) {
-            installation.status = 'failed';
-            installation.error = error instanceof Error ? error.message : 'Unknown error';
-            installation.logs?.push(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            installation.status = "failed";
+            installation.error =
+                error instanceof Error ? error.message : "Unknown error";
+            installation.logs?.push(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
             this.installHistory.set(installationId, installation);
             console.error(`Module installation failed:`, error);
         }
@@ -197,32 +210,32 @@ export class ModuleRegistryService extends EventEmitter {
     async getModule(moduleId) {
         return this.activeModules.get(moduleId) || null;
     }
-    async searchModules(query, category, tags, status = 'all', limit = 50, offset = 0) {
+    async searchModules(query, category, tags, status = "all", limit = 50, offset = 0) {
         let modules = Array.from(this.activeModules.values());
         // Filter by status
-        if (status !== 'all') {
-            modules = modules.filter(module => {
-                if (status === 'active')
-                    return module.status === 'running';
-                if (status === 'inactive')
-                    return module.status !== 'running';
+        if (status !== "all") {
+            modules = modules.filter((module) => {
+                if (status === "active")
+                    return module.status === "running";
+                if (status === "inactive")
+                    return module.status !== "running";
                 return true;
             });
         }
         // Filter by search query
         if (query) {
             const searchTerm = query.toLowerCase();
-            modules = modules.filter(module => module.name.toLowerCase().includes(searchTerm) ||
+            modules = modules.filter((module) => module.name.toLowerCase().includes(searchTerm) ||
                 module.displayName.toLowerCase().includes(searchTerm) ||
                 module.description.toLowerCase().includes(searchTerm));
         }
         // Filter by category
         if (category) {
-            modules = modules.filter(module => module.category === category);
+            modules = modules.filter((module) => module.category === category);
         }
         // Filter by tags
         if (tags && tags.length > 0) {
-            modules = modules.filter(module => tags.some(tag => module.tags.includes(tag)));
+            modules = modules.filter((module) => tags.some((tag) => module.tags.includes(tag)));
         }
         // Apply pagination
         return modules.slice(offset, offset + limit);
@@ -230,40 +243,44 @@ export class ModuleRegistryService extends EventEmitter {
     async getStats() {
         const modules = Array.from(this.activeModules.values());
         const categoryCounts = {};
-        modules.forEach(module => {
-            categoryCounts[module.category] = (categoryCounts[module.category] || 0) + 1;
+        modules.forEach((module) => {
+            categoryCounts[module.category] =
+                (categoryCounts[module.category] || 0) + 1;
         });
         return {
             totalModules: modules.length,
-            activeModules: modules.filter(m => m.status === 'running').length,
-            stoppedModules: modules.filter(m => m.status === 'stopped').length,
-            errorModules: modules.filter(m => m.status === 'error').length,
+            activeModules: modules.filter((m) => m.status === "running").length,
+            stoppedModules: modules.filter((m) => m.status === "stopped").length,
+            errorModules: modules.filter((m) => m.status === "error").length,
             totalInstallations: this.installHistory.size,
             categoryCounts,
-            recentActivity: this.recentActivity.slice(-10)
+            recentActivity: this.recentActivity.slice(-10),
         };
     }
     // Health and monitoring methods
     async updateHeartbeat(moduleId, heartbeatData) {
         const module = this.activeModules.get(moduleId);
         if (!module) {
-            return { success: false, message: 'Module not found' };
+            return { success: false, message: "Module not found" };
         }
         try {
             module.lastHeartbeat = new Date();
             module.metrics = heartbeatData.metrics;
-            if (heartbeatData.status === 'healthy') {
-                module.status = 'running';
+            if (heartbeatData.status === "healthy") {
+                module.status = "running";
             }
-            else if (heartbeatData.status === 'unhealthy') {
-                module.status = 'error';
+            else if (heartbeatData.status === "unhealthy") {
+                module.status = "error";
             }
             this.activeModules.set(moduleId, module);
-            return { success: true, message: 'Heartbeat updated' };
+            return { success: true, message: "Heartbeat updated" };
         }
         catch (error) {
-            console.error('Failed to update heartbeat:', error);
-            return { success: false, message: error instanceof Error ? error.message : 'Unknown error' };
+            console.error("Failed to update heartbeat:", error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : "Unknown error",
+            };
         }
     }
     async checkModuleHealth(moduleId) {
@@ -273,7 +290,7 @@ export class ModuleRegistryService extends EventEmitter {
         }
         try {
             const response = await fetch(`http://localhost:${module.api.backend.port}/health`, {
-                signal: AbortSignal.timeout(5000)
+                signal: AbortSignal.timeout(5000),
             });
             const health = {
                 healthy: response.ok,
@@ -283,8 +300,8 @@ export class ModuleRegistryService extends EventEmitter {
                 details: response.ok ? await response.json() : null,
                 checks: {
                     http: response.ok,
-                    status: response.status
-                }
+                    status: response.status,
+                },
             };
             module.health = health;
             this.activeModules.set(moduleId, module);
@@ -293,12 +310,12 @@ export class ModuleRegistryService extends EventEmitter {
         catch (error) {
             const health = {
                 healthy: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
+                error: error instanceof Error ? error.message : "Unknown error",
                 timestamp: new Date(),
                 checks: {
                     http: false,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                }
+                    error: error instanceof Error ? error.message : "Unknown error",
+                },
             };
             module.health = health;
             this.activeModules.set(moduleId, module);
@@ -307,8 +324,8 @@ export class ModuleRegistryService extends EventEmitter {
     }
     // Utility methods
     validateModule(module) {
-        const requiredFields = ['name', 'version', 'api'];
-        return requiredFields.every(field => module[field] !== undefined);
+        const requiredFields = ["name", "version", "api"];
+        return requiredFields.every((field) => module[field] !== undefined);
     }
     checkPortConflicts(module) {
         for (const [_, existingModule] of this.activeModules) {
@@ -337,29 +354,29 @@ export class ModuleRegistryService extends EventEmitter {
         }
     }
     async startModuleProcesses(module) {
-        const modulePath = path.join(process.cwd(), 'installed_modules', module.name);
+        const modulePath = path.join(process.cwd(), "installed_modules", module.name);
         try {
             // Start backend process
-            const backendProcess = spawn('npm', ['run', 'start'], {
-                cwd: path.join(modulePath, 'src', 'backend'),
-                stdio: 'pipe',
-                env: { ...process.env, NODE_ENV: 'production' }
+            const backendProcess = spawn("npm", ["run", "start"], {
+                cwd: path.join(modulePath, "src", "backend"),
+                stdio: "pipe",
+                env: { ...process.env, NODE_ENV: "production" },
             });
             // Start frontend process
-            const frontendProcess = spawn('npm', ['run', 'start'], {
-                cwd: path.join(modulePath, 'src', 'frontend'),
-                stdio: 'pipe',
-                env: { ...process.env, NODE_ENV: 'production' }
+            const frontendProcess = spawn("npm", ["run", "start"], {
+                cwd: path.join(modulePath, "src", "frontend"),
+                stdio: "pipe",
+                env: { ...process.env, NODE_ENV: "production" },
             });
             this.moduleProcesses.set(module.name, {
                 backend: backendProcess,
-                frontend: frontendProcess
+                frontend: frontendProcess,
             });
             // Handle process events
-            backendProcess.on('error', (error) => {
+            backendProcess.on("error", (error) => {
                 console.error(`Backend process error for ${module.name}:`, error);
             });
-            frontendProcess.on('error', (error) => {
+            frontendProcess.on("error", (error) => {
                 console.error(`Frontend process error for ${module.name}:`, error);
             });
         }
@@ -374,10 +391,10 @@ export class ModuleRegistryService extends EventEmitter {
             return;
         try {
             if (processes.backend) {
-                processes.backend.kill('SIGTERM');
+                processes.backend.kill("SIGTERM");
             }
             if (processes.frontend) {
-                processes.frontend.kill('SIGTERM');
+                processes.frontend.kill("SIGTERM");
             }
             this.moduleProcesses.delete(moduleId);
         }
@@ -387,57 +404,57 @@ export class ModuleRegistryService extends EventEmitter {
     }
     async installFromRemote(installation) {
         // Implementation for remote Git repository installation
-        const { exec } = await import('child_process');
-        const util = await import('util');
+        const { exec } = await import("child_process");
+        const util = await import("util");
         const execAsync = util.promisify(exec);
-        const targetDir = path.join(process.cwd(), 'installed_modules', installation.moduleId);
+        const targetDir = path.join(process.cwd(), "installed_modules", installation.moduleId);
         try {
             // Update progress
             installation.progress = 20;
-            installation.logs?.push('Cloning repository...');
+            installation.logs?.push("Cloning repository...");
             // Clone repository
             await execAsync(`git clone ${installation.source.url} ${targetDir}`);
             // Update progress
             installation.progress = 40;
-            installation.logs?.push('Repository cloned');
+            installation.logs?.push("Repository cloned");
             // Checkout specific version if provided
-            if (installation.version && installation.version !== 'latest') {
+            if (installation.version && installation.version !== "latest") {
                 await execAsync(`cd ${targetDir} && git checkout ${installation.version}`);
                 installation.logs?.push(`Checked out version ${installation.version}`);
             }
             // Update progress
             installation.progress = 60;
-            installation.logs?.push('Installing dependencies...');
+            installation.logs?.push("Installing dependencies...");
             // Install dependencies
             await execAsync(`cd ${targetDir} && npm run install:all`);
             // Update progress
             installation.progress = 80;
-            installation.logs?.push('Building module...');
+            installation.logs?.push("Building module...");
             // Build module
             await execAsync(`cd ${targetDir} && npm run build`);
             // Update progress
             installation.progress = 90;
-            installation.logs?.push('Loading module manifest...');
+            installation.logs?.push("Loading module manifest...");
             // Load module manifest
-            const manifestPath = path.join(targetDir, 'module.json');
-            const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+            const manifestPath = path.join(targetDir, "module.json");
+            const manifestContent = await fs.readFile(manifestPath, "utf-8");
             const manifest = JSON.parse(manifestContent);
             // Add to available modules
             this.availableModules.set(installation.moduleId, manifest);
-            installation.logs?.push('Module installed successfully');
+            installation.logs?.push("Module installed successfully");
         }
         catch (error) {
-            installation.logs?.push(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            installation.logs?.push(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
             throw error;
         }
     }
     async installFromMarketplace(installation) {
         // Implementation for marketplace installation
-        throw new Error('Marketplace installation not yet implemented');
+        throw new Error("Marketplace installation not yet implemented");
     }
     async installFromContainer(installation) {
         // Implementation for container-based installation
-        throw new Error('Container installation not yet implemented');
+        throw new Error("Container installation not yet implemented");
     }
     generateInstallationId() {
         return `install_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -446,7 +463,7 @@ export class ModuleRegistryService extends EventEmitter {
         this.recentActivity.push({
             type,
             moduleId,
-            timestamp: new Date()
+            timestamp: new Date(),
         });
         // Keep only last 100 activities
         if (this.recentActivity.length > 100) {
@@ -482,40 +499,48 @@ export class ModuleRegistryService extends EventEmitter {
             try {
                 let result;
                 switch (operation) {
-                    case 'activate':
+                    case "activate":
                         result = await this.activateModule(moduleId);
                         break;
-                    case 'deactivate':
+                    case "deactivate":
                         result = await this.deactivateModule(moduleId);
                         break;
-                    case 'restart':
+                    case "restart":
                         await this.deactivateModule(moduleId);
                         result = await this.activateModule(moduleId);
                         break;
-                    case 'uninstall':
+                    case "uninstall":
                         result = await this.unregisterModule(moduleId);
                         break;
                 }
-                results.push({ moduleId, success: result.success, message: result.message });
+                results.push({
+                    moduleId,
+                    success: result.success,
+                    message: result.message,
+                });
             }
             catch (error) {
-                results.push({ moduleId, success: false, message: error instanceof Error ? error.message : 'Unknown error' });
+                results.push({
+                    moduleId,
+                    success: false,
+                    message: error instanceof Error ? error.message : "Unknown error",
+                });
             }
         }
         return results;
     }
     subscribeToEvents(callback) {
-        this.on('module:registered', callback);
-        this.on('module:unregistered', callback);
-        this.on('module:activated', callback);
-        this.on('module:deactivated', callback);
-        this.on('module:installed', callback);
+        this.on("module:registered", callback);
+        this.on("module:unregistered", callback);
+        this.on("module:activated", callback);
+        this.on("module:deactivated", callback);
+        this.on("module:installed", callback);
         return () => {
-            this.off('module:registered', callback);
-            this.off('module:unregistered', callback);
-            this.off('module:activated', callback);
-            this.off('module:deactivated', callback);
-            this.off('module:installed', callback);
+            this.off("module:registered", callback);
+            this.off("module:unregistered", callback);
+            this.off("module:activated", callback);
+            this.off("module:deactivated", callback);
+            this.off("module:installed", callback);
         };
     }
 }