vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/AgentInstallationService.js

@@ -0,0 +1,140 @@
+/**
+ * Agent Installation Service
+ * 
+ * Simplified service that delegates to InstallationOrchestrator.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const InstallationOrchestrator = require('./InstallationOrchestrator');
+const { AgentStatus } = require('./AgentStatus');
+const { OperationType, OperationStatus } = require('./OperationTypes');
+
+/**
+ * Agent Installation Service class
+ */
+class AgentInstallationService {
+  /**
+   * Create installation service instance
+   * @param {Object} config - Service configuration
+   */
+  constructor(config = {}) {
+    this.configManager = config.configManager || null;
+    this.logger = config.logger || null;
+    this.fileManager = config.fileManager || null;
+    this.parallel = config.parallel !== false;
+    this.maxConcurrency = config.maxConcurrency || 2;
+    this.timeout = config.timeout || 300000;
+    this.retryAttempts = config.retryAttempts || 3;
+    this.retryDelay = config.retryDelay || 5000;
+    
+    // Initialize orchestrator
+    this.orchestrator = new InstallationOrchestrator({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      parallel: this.parallel,
+      maxConcurrency: this.maxConcurrency,
+      timeout: this.timeout,
+      retryAttempts: this.retryAttempts,
+      retryDelay: this.retryDelay,
+      ...config.orchestrator
+    });
+  }
+
+  /**
+   * Install agent using orchestrator
+   * @param {Object} agent - Agent to install
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} - Installation result
+   */
+  async installAgent(agent, options = {}) {
+    return this.orchestrator.installAgent(agent, options);
+  }
+
+  /**
+   * Install multiple agents
+   * @param {Array<Object>} agents - Agents to install
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} - Batch installation result
+   */
+  async installAgents(agents, options = {}) {
+    const results = {
+      success: true,
+      totalAgents: agents.length,
+      completed: [],
+      failed: [],
+      summary: {
+        allSuccessful: true,
+        totalDuration: 0,
+        averageDuration: 0
+      }
+    };
+
+    const startTime = Date.now();
+    
+    if (this.parallel) {
+      // Parallel installation
+      const promises = agents.map(agent => 
+        this.installAgent(agent, options).catch(error => ({
+          success: false,
+          agentId: agent.id,
+          error: error.message || error
+        }))
+      );
+      
+      const agentResults = await Promise.all(promises);
+      
+      for (const result of agentResults) {
+        if (result.success) {
+          results.completed.push(result);
+        } else {
+          results.failed.push(result);
+          results.success = false;
+          results.summary.allSuccessful = false;
+        }
+      }
+    } else {
+      // Sequential installation
+      for (const agent of agents) {
+        try {
+          const result = await this.installAgent(agent, options);
+          results.completed.push(result);
+        } catch (error) {
+          results.failed.push({
+            success: false,
+            agentId: agent.id,
+            error: error.message || error
+          });
+          results.success = false;
+          results.summary.allSuccessful = false;
+        }
+      }
+    }
+
+    results.summary.totalDuration = Date.now() - startTime;
+    results.summary.averageDuration = results.summary.totalDuration / agents.length;
+
+    if (this.logger) {
+      await this.logger.info('Batch installation completed', {
+        totalAgents: results.totalAgents,
+        completed: results.completed.length,
+        failed: results.failed.length,
+        allSuccessful: results.summary.allSuccessful,
+        totalDuration: results.summary.totalDuration
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Create default installation service
+   * @param {Object} config - Configuration
+   * @returns {AgentInstallationService} - Service instance
+   */
+  static createDefault(config = {}) {
+    return new AgentInstallationService(config);
+  }
+}
+
+module.exports = AgentInstallationService;

package/src/agents/AgentSetupService.js

@@ -0,0 +1,467 @@
+/**
+ * Agent Setup Service
+ * 
+ * Handles interactive setup for agents including authentication and initialization.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { spawn } = require('child_process');
+const { VerificationType } = require('./VerificationType');
+
+/**
+ * Agent setup service class
+ */
+class AgentSetupService {
+  /**
+   * Create setup service instance
+   * @param {Object} options - Service options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.timeout = options.timeout || 60000; // 1 minute default for setup
+    this.maxRetries = options.maxRetries || 2;
+    this.interactiveMode = options.interactiveMode !== false; // Default to interactive
+  }
+
+  /**
+   * Perform setup for multiple agents
+   * @param {Object[]} agents - Array of agent configurations
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} - Batch setup result
+   */
+  async performSetupBatch(agents, options = {}) {
+    const batchId = `batch-setup-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting batch agent setup', {
+          batchId,
+          agentCount: agents.length
+        });
+      }
+
+      const results = {};
+      const promises = agents.map(async (agent) => {
+        const result = await this.performSetup(agent, options);
+        results[agent.id] = result;
+        return result;
+      });
+
+      // Wait for all setups to complete
+      await Promise.allSettled(promises);
+
+      const successful = Object.values(results).filter(r => r.success).length;
+      const total = agents.length;
+
+      return {
+        success: successful === total,
+        batchId,
+        totalAgents: total,
+        successful,
+        failed: total - successful,
+        results,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Batch agent setup failed', {
+          batchId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        batchId,
+        totalAgents: agents.length,
+        successful: 0,
+        failed: agents.length,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+
+  /**
+   * Perform interactive setup for an agent
+   * @param {Object} agent - Agent configuration
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} - Setup result
+   */
+  async performSetup(agent, options = {}) {
+    const setupId = `setup-${agent.id}-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting agent setup', {
+          setupId,
+          agentId: agent.id,
+          agentName: agent.name
+        });
+      }
+
+      // Check if agent has setup configuration
+      if (!agent.installation || !agent.installation.setup) {
+        return {
+          success: true,
+          agentId: agent.id,
+          setupId,
+          skipped: true,
+          message: 'No setup configuration found',
+          timestamp: new Date().toISOString(),
+          duration: Date.now() - startTime
+        };
+      }
+
+      const setupConfig = agent.installation.setup;
+      
+      // Run setup commands
+      const results = [];
+      for (const command of setupConfig.commands || []) {
+        const result = await this.executeSetupCommand(agent.id, command, options);
+        results.push(result);
+        
+        if (!result.success && setupConfig.type === 'interactive') {
+          // For interactive setup, stop on first failure
+          break;
+        }
+      }
+
+      // Run verification if configured
+      let verificationResult = null;
+      if (setupConfig.verification) {
+        verificationResult = await this.performVerification(agent, setupConfig.verification, options);
+      }
+
+      const allSuccessful = results.every(r => r.success) && 
+                          (!verificationResult || verificationResult.success);
+
+      return {
+        success: allSuccessful,
+        agentId: agent.id,
+        setupId,
+        results,
+        verification: verificationResult,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Agent setup failed', {
+          setupId,
+          agentId: agent.id,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        agentId: agent.id,
+        setupId,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+
+  /**
+   * Execute a setup command
+   * @param {string} agentId - Agent ID
+   * @param {string} command - Command to execute
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} - Command result
+   */
+  async executeSetupCommand(agentId, command, options = {}) {
+    const commandId = `cmd-${agentId}-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Executing setup command', {
+          commandId,
+          agentId,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, {
+        timeout: options.timeout || this.timeout,
+        interactive: this.interactiveMode,
+        ...options
+      });
+
+      return {
+        success: true,
+        commandId,
+        agentId,
+        command,
+        output: result.output,
+        exitCode: result.exitCode,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Setup command failed', {
+          commandId,
+          agentId,
+          command,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        commandId,
+        agentId,
+        command,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+
+  /**
+   * Perform verification after setup
+   * @param {Object} agent - Agent configuration
+   * @param {Object} verificationConfig - Verification configuration
+   * @param {Object} options - Verification options
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification(agent, verificationConfig, options = {}) {
+    const verificationId = `verify-${agent.id}-${Date.now()}`;
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Performing setup verification', {
+          verificationId,
+          agentId: agent.id,
+          type: verificationConfig.type
+        });
+      }
+
+      if (verificationConfig.type === 'communication') {
+        return await this.performCommunicationVerification(agent, verificationConfig, options);
+      } else {
+        return await this.performStandardVerification(agent, verificationConfig, options);
+      }
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Setup verification failed', {
+          verificationId,
+          agentId: agent.id,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        agentId: agent.id,
+        verificationId,
+        type: verificationConfig.type,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+
+  /**
+   * Perform communication verification
+   * @param {Object} agent - Agent configuration
+   * @param {Object} verificationConfig - Verification configuration
+   * @param {Object} options - Verification options
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performCommunicationVerification(agent, verificationConfig, options = {}) {
+    const { command, expectedOutput, timeout = 60000 } = verificationConfig;
+    
+    try {
+      const result = await this.executeCommand(command, {
+        timeout: options.timeout || timeout,
+        interactive: false // Non-interactive for verification
+      });
+
+      // Check if output matches expected patterns
+      const success = this.checkExpectedOutput(result.output, expectedOutput);
+
+      return {
+        success,
+        agentId: agent.id,
+        type: 'communication',
+        command,
+        expectedOutput,
+        actualOutput: result.output,
+        exitCode: result.exitCode,
+        matchedPatterns: success ? this.extractMatchingPatterns(result.output, expectedOutput) : [],
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - Date.now() // Will be updated by caller
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        agentId: agent.id,
+        type: 'communication',
+        command,
+        expectedOutput,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - Date.now() // Will be updated by caller
+      };
+    }
+  }
+
+  /**
+   * Perform standard verification
+   * @param {Object} agent - Agent configuration
+   * @param {Object} verificationConfig - Verification configuration
+   * @param {Object} options - Verification options
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performStandardVerification(agent, verificationConfig, options = {}) {
+    const { command, expectedOutput, timeout = 30000 } = verificationConfig;
+    
+    try {
+      const result = await this.executeCommand(command, {
+        timeout: options.timeout || timeout,
+        interactive: false
+      });
+
+      const success = this.checkExpectedOutput(result.output, expectedOutput);
+
+      return {
+        success,
+        agentId: agent.id,
+        type: verificationConfig.type,
+        command,
+        expectedOutput,
+        actualOutput: result.output,
+        exitCode: result.exitCode,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - Date.now() // Will be updated by caller
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        agentId: agent.id,
+        type: verificationConfig.type,
+        command,
+        expectedOutput,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - Date.now() // Will be updated by caller
+      };
+    }
+  }
+
+  /**
+   * Execute a command with timeout
+   * @param {string} command - Command to execute
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} - Command result
+   */
+  async executeCommand(command, options = {}) {
+    const { timeout = 30000, interactive = false } = options;
+    
+    return new Promise((resolve, reject) => {
+      const args = command.split(' ');
+      const cmd = args.shift();
+      
+      const child = spawn(cmd, args, {
+        stdio: interactive ? 'inherit' : 'pipe',
+        shell: true
+      });
+
+      let output = '';
+      let errorOutput = '';
+
+      if (!interactive) {
+        child.stdout?.on('data', (data) => {
+          output += data.toString();
+        });
+
+        child.stderr?.on('data', (data) => {
+          errorOutput += data.toString();
+        });
+      }
+
+      const timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Command timed out after ${timeout}ms`));
+      }, timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        
+        if (code === 0) {
+          resolve({
+            exitCode: code,
+            output: output.trim(),
+            errorOutput: errorOutput.trim()
+          });
+        } else {
+          reject(new Error(`Command failed with exit code ${code}: ${errorOutput.trim()}`));
+        }
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Check if output matches expected patterns
+   * @param {string} output - Actual output
+   * @param {string|string[]} expectedOutput - Expected output patterns
+   * @returns {boolean} - True if matches
+   */
+  checkExpectedOutput(output, expectedOutput) {
+    const patterns = Array.isArray(expectedOutput) ? expectedOutput : [expectedOutput];
+    
+    return patterns.some(pattern => {
+      const regex = new RegExp(pattern, 'i');
+      return regex.test(output);
+    });
+  }
+
+  /**
+   * Extract matching patterns from output
+   * @param {string} output - Actual output
+   * @param {string|string[]} expectedOutput - Expected output patterns
+   * @returns {string[]} - Matching patterns
+   */
+  extractMatchingPatterns(output, expectedOutput) {
+    const patterns = Array.isArray(expectedOutput) ? expectedOutput : [expectedOutput];
+    
+    return patterns.filter(pattern => {
+      const regex = new RegExp(pattern, 'i');
+      return regex.test(output);
+    });
+  }
+
+  /**
+   * Create default setup service instance
+   * @param {Object} options - Service options
+   * @returns {AgentSetupService} - Setup service instance
+   */
+  static createDefault(options = {}) {
+    return new AgentSetupService(options);
+  }
+}
+
+module.exports = AgentSetupService;