vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/InstallationOrchestrator.js

@@ -0,0 +1,352 @@
+/**
+ * Installation Orchestrator
+ * 
+ * Orchestrates agent installation across multiple installers.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const InstallerFactory = require('./windows/InstallerFactory');
+const InstallationErrorHandler = require('./InstallationErrorHandler');
+const InstallationProgressReporter = require('./InstallationProgressReporter');
+const { AgentStatus } = require('./AgentStatus');
+const { OperationType, OperationStatus } = require('./OperationTypes');
+
+/**
+ * Installation Orchestrator class
+ */
+class InstallationOrchestrator {
+  /**
+   * Create orchestrator instance
+   * @param {Object} config - Orchestrator 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 services
+    this.errorHandler = new InstallationErrorHandler({
+      logger: this.logger,
+      platform: config.platform,
+      arch: config.arch
+    });
+    
+    this.progressReporter = new InstallationProgressReporter({
+      logger: this.logger,
+      updateInterval: config.progressUpdateInterval || 2000,
+      verbose: config.verboseProgress || false
+    });
+  }
+
+  /**
+   * Install agent with orchestration
+   * @param {Object} agent - Agent to install
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} - Installation result
+   */
+  async installAgent(agent, options = {}) {
+    const { force = false, installerType = null, timeout = this.timeout } = options;
+    
+    if (this.logger) {
+      await this.logger.info('Starting agent installation', {
+        agentId: agent.id,
+        agentName: agent.name,
+        force,
+        installerType,
+        timeout
+      });
+    }
+
+    const startTime = Date.now();
+    const operationId = `install-${agent.id}-${Date.now()}`;
+    
+    try {
+      // Update agent status to INSTALLING
+      await this.updateAgentStatus(agent.id, AgentStatus.INSTALLING, 'Starting installation');
+      
+      // Get available installers first
+      const installers = await this.getAvailableInstallers(agent, installerType);
+      
+      // Start progress tracking
+      const progress = this.progressReporter.startProgress(operationId, {
+        agentId: agent.id,
+        installerType: installerType || 'AUTO',
+        totalSteps: installers.length * 2 + 2,
+        estimatedDuration: timeout
+      });
+      
+      progress.updateStep('Checking available installers');
+      
+      if (installers.length === 0) {
+        progress.fail(new Error('No available installers found for agent'));
+        throw new Error('No available installers found for agent');
+      }
+
+      progress.updateStep(`Found ${installers.length} available installers`, { 
+        installers: installers.map(i => i.type) 
+      });
+
+      // Try installers in order of preference
+      let installationResult = await this.tryInstallers(agent, installers, progress, options);
+      
+      if (!installationResult || !installationResult.success) {
+        progress.fail(new Error('All installation attempts failed'));
+        throw new Error('All installation attempts failed');
+      }
+
+      progress.complete(installationResult);
+
+      const duration = Date.now() - startTime;
+      
+      // Log installation success
+      await this.logInstallation(agent, installationResult, duration);
+      
+      return {
+        success: true,
+        agentId: agent.id,
+        installerType: installationResult.installer,
+        duration,
+        result: installationResult,
+        timestamp: new Date().toISOString()
+      };
+
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      // Enhanced error handling for main installation failure
+      const enhancedError = this.errorHandler.handleError(error, {
+        agentId: agent.id,
+        installerType: installerType || 'AUTO',
+        phase: 'MAIN_INSTALLATION'
+      });
+      
+      // Update agent status to ERROR
+      await this.updateAgentStatus(agent.id, AgentStatus.ERROR, enhancedError.userMessage);
+      
+      if (this.logger) {
+        await this.logger.error('Agent installation failed', {
+          agentId: agent.id,
+          duration,
+          error: error.message,
+          enhancedError: enhancedError.userMessage,
+          category: enhancedError.category,
+          severity: enhancedError.severity,
+          resolutionSteps: enhancedError.resolutionSteps
+        });
+      }
+      
+      return {
+        success: false,
+        agentId: agent.id,
+        error: enhancedError.userMessage,
+        technicalError: error.message,
+        category: enhancedError.category,
+        severity: enhancedError.severity,
+        resolutionSteps: enhancedError.resolutionSteps,
+        duration,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Try installers in order
+   * @param {Object} agent - Agent to install
+   * @param {Array} installers - Available installers
+   * @param {Object} progress - Progress tracker
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} - Installation result
+   */
+  async tryInstallers(agent, installers, progress, options) {
+    let lastError = null;
+    
+    for (const installer of installers) {
+      try {
+        progress.updateStep(`Trying ${installer.type} installer`);
+        
+        if (this.logger) {
+          await this.logger.info(`Trying installer: ${installer.type}`, {
+            agentId: agent.id,
+            installerType: installer.type
+          });
+        }
+
+        // Check requirements before installation
+        progress.updateStep(`Checking ${installer.type} requirements`);
+        const requirements = await installer.checkRequirements();
+        if (!requirements.allMet) {
+          const unmet = requirements.requirements
+            .filter(req => !req.met)
+            .map(req => req.requirement);
+          
+          progress.updateStep(`${installer.type} requirements not met`, { unmet });
+          
+          if (this.logger) {
+            await this.logger.warn(`Installer requirements not met: ${installer.type}`, {
+              agentId: agent.id,
+              installerType: installer.type,
+              unmetRequirements: unmet
+            });
+          }
+          
+          lastError = new Error(`Requirements not met: ${unmet.join(', ')}`);
+          continue;
+        }
+
+        progress.updateStep(`Installing with ${installer.type}`);
+        const installationResult = await installer.install(agent, { 
+          force: options.force, 
+          timeout: Math.floor(options.timeout / installers.length) 
+        });
+        
+        if (installationResult && installationResult.success) {
+          progress.updateStep(`${installer.type} installation successful`, {
+            result: installationResult
+          });
+          return installationResult;
+        } else {
+          progress.updateStep(`${installer.type} installation failed`);
+        }
+        
+      } catch (error) {
+        lastError = error;
+        
+        // Enhanced error handling with comprehensive messages
+        const enhancedError = this.errorHandler.handleError(error, {
+          agentId: agent.id,
+          installerType: installer.type,
+          command: installer.command,
+          phase: 'INSTALLATION'
+        });
+        
+        if (this.logger) {
+          await this.logger.error(`Installer error: ${installer.type}`, {
+            agentId: agent.id,
+            installerType: installer.type,
+            error: error.message,
+            enhancedError: enhancedError.userMessage,
+            category: enhancedError.category,
+            severity: enhancedError.severity
+          });
+        }
+      }
+    }
+
+    throw lastError || new Error('All installation attempts failed');
+  }
+
+  /**
+   * Get available installers for agent
+   * @param {Object} agent - Agent configuration
+   * @param {string} preferredType - Preferred installer type
+   * @returns {Promise<Array>} - Available installers
+   */
+  async getAvailableInstallers(agent, preferredType = null) {
+    const installers = [];
+    
+    if (preferredType) {
+      // Try preferred installer first
+      try {
+        const installer = InstallerFactory.create(preferredType, {
+          configManager: this.configManager,
+          logger: this.logger,
+          fileManager: this.fileManager
+        });
+        
+        const isAvailable = await installer.isAvailable();
+        const requirements = await installer.checkRequirements();
+        
+        if (isAvailable && requirements.allMet) {
+          installers.push(installer);
+        }
+      } catch (error) {
+        if (this.logger) {
+          await this.logger.warn(`Preferred installer not available: ${preferredType}`, {
+            agentId: agent.id,
+            error: error.message
+          });
+        }
+      }
+    }
+
+    // Try all available installers
+    const availableTypes = ['WINGET', 'NPM', 'POWERSHELL', 'CHOCOLATEY', 'DIRECT'];
+    
+    for (const type of availableTypes) {
+      if (type === preferredType) continue; // Already tried preferred
+      
+      try {
+        const installer = InstallerFactory.create(type, {
+          configManager: this.configManager,
+          logger: this.logger,
+          fileManager: this.fileManager
+        });
+        
+        const isAvailable = await installer.isAvailable();
+        const requirements = await installer.checkRequirements();
+        
+        if (isAvailable && requirements.allMet) {
+          installers.push(installer);
+        }
+      } catch (error) {
+        if (this.logger) {
+          await this.logger.warn(`Installer check failed: ${type}`, {
+            agentId: agent.id,
+            error: error.message
+          });
+        }
+      }
+    }
+
+    // Sort by priority
+    return installers.sort((a, b) => (a.priority || 999) - (b.priority || 999));
+  }
+
+  /**
+   * Update agent status
+   * @param {string} agentId - Agent identifier
+   * @param {string} status - New status
+   * @param {string} message - Status message
+   */
+  async updateAgentStatus(agentId, status, message) {
+    if (this.configManager && this.configManager.updateAgentStatus) {
+      try {
+        await this.configManager.updateAgentStatus(agentId, status, message);
+      } catch (error) {
+        if (this.logger) {
+          await this.logger.warn('Failed to update agent status', {
+            agentId,
+            status,
+            error: error.message
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Log installation result
+   * @param {Object} agent - Agent configuration
+   * @param {Object} result - Installation result
+   * @param {number} duration - Installation duration
+   */
+  async logInstallation(agent, result, duration) {
+    if (this.logger) {
+      await this.logger.info('Agent installation completed', {
+        agentId: agent.id,
+        agentName: agent.name,
+        installerType: result.installer,
+        duration,
+        success: result.success,
+        exitCode: result.exitCode
+      });
+    }
+  }
+}
+
+module.exports = InstallationOrchestrator;