vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/AgentCheckService.js

@@ -0,0 +1,690 @@
+/**
+ * Agent Check Service
+ * 
+ * Main service for checking agents (install + verify).
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentInstallationService = require('./AgentInstallationService');
+const AgentVerificationService = require('./AgentVerificationService');
+const AgentSetupService = require('./AgentSetupService');
+const AgentDiscoveryService = require('./discovery/AgentDiscoveryService');
+const { AgentStatus } = require('./AgentStatus');
+
+/**
+ * Agent check service class
+ */
+class AgentCheckService {
+  /**
+   * Create check service instance
+   * @param {Object} config - Service configuration
+   */
+  constructor(config = {}) {
+    this.configManager = config.configManager || null;
+    this.logger = config.logger || null;
+    this.fileManager = config.fileManager || null;
+    
+    // Create sub-services
+    this.installationService = AgentInstallationService.createDefault({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      ...config.installation
+    });
+    
+    this.verificationService = AgentVerificationService.createDefault({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      ...config.verification
+    });
+    
+    this.setupService = AgentSetupService.createDefault({
+      logger: this.logger,
+      ...config.setup
+    });
+    
+    this.discoveryService = new AgentDiscoveryService({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      ...config.discovery
+    });
+    
+    // Service configuration
+    this.parallel = config.parallel !== false;
+    this.maxConcurrency = config.maxConcurrency || 2;
+    this.timeout = config.timeout || 600000; // 10 minutes default
+    this.forceReinstall = config.forceReinstall || false;
+    this.skipVerification = config.skipVerification || false;
+  }
+
+  /**
+   * Check agents (install + verify)
+   * @param {Object} options - Check options
+   * @returns {Promise<Object>} - Check results
+   */
+  async checkAgents(options = {}) {
+    const { 
+      agentIds = null, 
+      forceReinstall = this.forceReinstall,
+      skipVerification = this.skipVerification,
+      timeout = this.timeout,
+      parallel = this.parallel,
+      maxConcurrency = this.maxConcurrency
+    } = options;
+
+    if (this.logger) {
+      await this.logger.info('Starting agent check operation', {
+        agentIds,
+        forceReinstall,
+        skipVerification,
+        timeout,
+        parallel,
+        maxConcurrency
+      });
+    }
+
+    const startTime = Date.now();
+    const results = {
+      totalAgents: 0,
+      installationResults: {},
+      verificationResults: {},
+      summary: {
+        allSuccessful: false,
+        hasFailures: false,
+        hasSkipped: false
+      },
+      duration: 0,
+      timestamp: new Date().toISOString()
+    };
+
+    try {
+      // Get agents to check
+      const agents = await this.getAgentsToCheck(agentIds);
+      results.totalAgents = agents.length;
+      
+      if (agents.length === 0) {
+        return {
+          ...results,
+          message: 'No agents to check',
+          skipped: true
+        };
+      }
+
+      // Phase 1: Installation
+      if (this.logger) {
+        await this.logger.info('Phase 1: Agent Installation', {
+          agentCount: agents.length
+        });
+      }
+
+      const installationOptions = {
+        force: forceReinstall,
+        timeout: Math.floor(timeout * 0.6), // 60% of timeout for installation
+        parallel,
+        maxConcurrency
+      };
+
+      const installationResults = await this.installationService.installAgents(agents, installationOptions);
+      results.installationResults = installationResults.results;
+
+      // Phase 2: Setup (only if installation succeeded)
+      const successfullyInstalled = agents.filter(agent => {
+        const installResult = installationResults.results[agent.id];
+        return installResult && installResult.success;
+      });
+
+      let setupResults = null;
+      if (successfullyInstalled.length > 0) {
+        if (this.logger) {
+          await this.logger.info('Phase 2: Agent Setup', {
+            agentCount: successfullyInstalled.length
+          });
+        }
+
+        const setupOptions = {
+          timeout: Math.floor(timeout * 0.2), // 20% of timeout for setup
+          interactive: options.interactiveSetup !== false
+        };
+
+        setupResults = await this.setupService.performSetupBatch(successfullyInstalled, setupOptions);
+        results.setupResults = setupResults.results;
+      } else {
+        if (this.logger) {
+          await this.logger.warn('No agents successfully installed, skipping setup');
+        }
+      }
+
+      // Phase 3: Verification (only if installation succeeded and not skipped)
+      if (!skipVerification) {
+        if (this.logger) {
+          await this.logger.info('Phase 3: Agent Verification', {
+            agentCount: successfullyInstalled.length,
+            skipVerification: false
+          });
+        }
+
+        if (successfullyInstalled.length > 0) {
+          const verificationOptions = {
+            timeout: Math.floor(timeout * 0.2), // 20% of timeout for verification
+            parallel,
+            maxConcurrency
+          };
+
+          const verificationResults = await this.verificationService.verifyAgents(successfullyInstalled, verificationOptions);
+          results.verificationResults = verificationResults.results;
+        } else {
+          if (this.logger) {
+            await this.logger.warn('No agents successfully installed, skipping verification');
+          }
+        }
+      } else {
+        if (this.logger) {
+          await this.logger.info('Verification skipped by configuration');
+        }
+      }
+
+      // Calculate overall summary
+      this.calculateOverallSummary(results);
+      
+      results.duration = Date.now() - startTime;
+      
+      // Log overall check completion
+      await this.logCheckCompletion(results);
+      
+    } catch (error) {
+      results.duration = Date.now() - startTime;
+      results.error = error.message;
+      
+      if (this.logger) {
+        await this.logger.error('Agent check operation failed', {
+          agentIds,
+          error: error.message,
+          duration: results.duration
+        });
+      }
+      
+      await this.logCheckError(error, results.duration);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get agents to check
+   * @param {Array<string>} agentIds - Specific agent IDs
+   * @returns {Promise<Array>} - Agents to check
+   */
+  async getAgentsToCheck(agentIds) {
+    try {
+      if (agentIds && agentIds.length > 0) {
+        // Get specific agents
+        const agents = [];
+        for (const agentId of agentIds) {
+          const agent = this.configManager.getAgent(agentId);
+          if (agent && agent.enabled) {
+            agents.push(agent);
+          }
+        }
+        return agents;
+      } else {
+        // Get all enabled agents
+        return this.configManager.getEnabledAgents();
+      }
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get agents to check', {
+          agentIds,
+          error: error.message
+        });
+      }
+      return [];
+    }
+  }
+
+  /**
+   * Calculate overall summary
+   * @param {Object} results - Results object to update
+   */
+  calculateOverallSummary(results) {
+    let allSuccessful = true;
+    let hasFailures = false;
+    let hasSkipped = false;
+
+    // Check installation results
+    for (const [agentId, installResult] of Object.entries(results.installationResults)) {
+      if (!installResult.success) {
+        allSuccessful = false;
+        hasFailures = true;
+      }
+    }
+
+    // Check verification results
+    for (const [agentId, verifyResult] of Object.entries(results.verificationResults)) {
+      if (!verifyResult.success) {
+        allSuccessful = false;
+        hasFailures = true;
+      }
+      
+      if (verifyResult.skipped) {
+        hasSkipped = true;
+      }
+    }
+
+    results.summary = {
+      allSuccessful,
+      hasFailures,
+      hasSkipped
+    };
+  }
+
+  /**
+   * Log check completion
+   * @param {Object} results - Check results
+   */
+  async logCheckCompletion(results) {
+    if (this.fileManager) {
+      await this.fileManager.writeLog('agent-check', {
+        operation: 'CHECK_AGENTS',
+        status: results.summary.allSuccessful ? 'COMPLETED' : 'FAILED',
+        message: `Agent check ${results.summary.allSuccessful ? 'completed' : 'failed'}`,
+        duration: results.duration,
+        results,
+        summary: results.summary,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  /**
+   * Log check error
+   * @param {Error} error - Error that occurred
+   * @param {number} duration - Operation duration
+   */
+  async logCheckError(error, duration) {
+    if (this.fileManager) {
+      await this.fileManager.writeLog('agent-check', {
+        operation: 'CHECK_AGENTS',
+        status: 'FAILED',
+        message: `Agent check failed: ${error.message}`,
+        duration,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  /**
+   * Get check operation statistics
+   * @returns {Promise<Object>} - Check statistics
+   */
+  async getCheckStatistics() {
+    try {
+      const agents = this.configManager.getEnabledAgents();
+      
+      const stats = {
+        totalAgents: agents.length,
+        verified: 0,
+        notVerified: 0,
+        error: 0,
+        installing: 0,
+        lastCheck: null,
+        checkRate: 0
+      };
+
+      let latestCheck = null;
+      
+      for (const agent of agents) {
+        const status = await this.configManager.getAgentStatus(agent.id);
+        
+        if (status) {
+          switch (status.status) {
+            case AgentStatus.VERIFIED:
+              stats.verified++;
+              break;
+            case AgentStatus.NOT_INSTALLED:
+            case AgentStatus.INSTALLED:
+              stats.notVerified++;
+              break;
+            case AgentStatus.ERROR:
+              stats.error++;
+              break;
+            case AgentStatus.INSTALLING:
+              stats.installing++;
+              break;
+          }
+          
+          // Track latest check
+          if (status.lastChecked) {
+            const checkDate = new Date(status.lastChecked);
+            if (!latestCheck || checkDate > latestCheck) {
+              latestCheck = status.lastChecked;
+            }
+          }
+        } else {
+          stats.notVerified++;
+        }
+      }
+      
+      stats.lastCheck = latestCheck ? latestCheck.toISOString() : null;
+      
+      // Calculate check rate (agents that have been checked at least once)
+      const checkedAgents = stats.verified + stats.notVerified + stats.error;
+      stats.checkRate = agents.length > 0 ? (checkedAgents / agents.length) * 100 : 0;
+      
+      return stats;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get check statistics', {
+          error: error.message
+        });
+      }
+      
+      return {
+        totalAgents: 0,
+        verified: 0,
+        notVerified: 0,
+        error: 0,
+        installing: 0,
+        lastCheck: null,
+        checkRate: 0,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get detailed agent status
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<Object>} - Detailed agent status
+   */
+  async getDetailedAgentStatus(agentId) {
+    try {
+      const agent = this.configManager.getAgent(agentId);
+      if (!agent) {
+        return {
+          agentId,
+          found: false,
+          error: 'Agent not found'
+        };
+      }
+
+      const status = await this.configManager.getAgentStatus(agentId);
+      const history = await this.getStatusHistory(agentId, 10);
+      
+      return {
+        agentId,
+        found: true,
+        agent: {
+          id: agent.id,
+          name: agent.name,
+          description: agent.description,
+          enabled: agent.enabled,
+          status: status ? status.status : AgentStatus.NOT_INSTALLED,
+          lastChecked: status ? status.lastChecked : null,
+          lastVerified: status ? status.lastVerified : null,
+          message: status ? status.message : '',
+          installationMethods: agent.installationMethods,
+          verificationCommands: agent.verificationCommands
+        },
+        status,
+        history,
+        canInstall: agent.enabled && status ? status.status === AgentStatus.NOT_INSTALLED : false,
+        canVerify: agent.enabled && status ? [AgentStatus.INSTALLED, AgentStatus.VERIFIED].includes(status.status) : false
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get detailed agent status', {
+          agentId,
+          error: error.message
+        });
+      }
+      
+      return {
+        agentId,
+        found: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get status history for an agent
+   * @param {string} agentId - Agent identifier
+   * @param {number} limit - Maximum entries
+   * @returns {Promise<Array>} - Status history
+   */
+  async getStatusHistory(agentId, limit = 50) {
+    try {
+      if (this.fileManager) {
+        const logs = await this.fileManager.readLogs('status-change', { limit });
+        return logs
+          .filter(log => log.agentId === agentId)
+          .slice(-limit)
+          .reverse(); // Most recent first
+      }
+      return [];
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to get status history', {
+          agentId,
+          error: error.message
+        });
+      }
+      return [];
+    }
+  }
+
+  /**
+   * Discover new agents in the system
+   * @param {Object} options - Discovery options
+   * @returns {Promise<Object>} - Discovery results
+   */
+  async discoverAgents(options = {}) {
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting agent discovery', options);
+      }
+
+      const discoveryOptions = {
+        includeDisabled: options.includeDisabled || false,
+        scanSystem: options.scanSystem !== false,
+        scanConfigFiles: options.scanConfigFiles !== false,
+        timeout: options.timeout || 300000, // 5 minutes
+        ...options
+      };
+
+      const discoveryResult = await this.discoveryService.discoverAgents(discoveryOptions);
+
+      if (this.logger) {
+        await this.logger.info('Agent discovery completed', {
+          discoveredCount: discoveryResult.discovered?.length || 0,
+          newCount: discoveryResult.new?.length || 0,
+          existingCount: discoveryResult.existing?.length || 0
+        });
+      }
+
+      return {
+        success: true,
+        ...discoveryResult,
+        message: `Discovered ${discoveryResult.discovered?.length || 0} agents (${discoveryResult.new?.length || 0} new)`
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Agent discovery failed', { error: error.message });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        message: 'Agent discovery failed'
+      };
+    }
+  }
+
+  /**
+   * Check agents with discovery (discover + install + verify)
+   * @param {Object} options - Check options with discovery
+   * @returns {Promise<Object>} - Combined check and discovery results
+   */
+  async checkAgentsWithDiscovery(options = {}) {
+    const {
+      runDiscovery = true,
+      addDiscovered = false,
+      ...checkOptions
+    } = options;
+
+    try {
+      const startTime = Date.now();
+      const results = {
+        discovery: null,
+        check: null,
+        summary: {
+          totalDuration: 0,
+          discoverySuccessful: false,
+          checkSuccessful: false,
+          newAgentsDiscovered: 0,
+          agentsChecked: 0
+        }
+      };
+
+      // Phase 0: Discovery (if requested)
+      if (runDiscovery) {
+        if (this.logger) {
+          await this.logger.info('Phase 0: Agent Discovery');
+        }
+
+        const discoveryOptions = {
+          includeDisabled: false,
+          scanSystem: true,
+          scanConfigFiles: true,
+          timeout: Math.floor((checkOptions.timeout || 600000) * 0.2), // 20% of time for discovery
+          ...options.discovery
+        };
+
+        results.discovery = await this.discoverAgents(discoveryOptions);
+        results.summary.discoverySuccessful = results.discovery.success;
+        results.summary.newAgentsDiscovered = results.discovery.new?.length || 0;
+
+        // Add discovered agents if requested
+        if (addDiscovered && results.discovery.new?.length > 0) {
+          if (this.logger) {
+            await this.logger.info(`Adding ${results.discovery.new.length} discovered agents`);
+          }
+
+          // Note: This would require AgentAdditionService integration
+          // For now, just log the discovered agents
+          for (const agent of results.discovery.new) {
+            if (this.logger) {
+              await this.logger.info(`Discovered new agent: ${agent.id} (${agent.name})`);
+            }
+          }
+        }
+      }
+
+      // Phase 1+: Regular agent check
+      if (this.logger) {
+        await this.logger.info('Phase 1+: Agent Check (Install + Verify)');
+      }
+
+      results.check = await this.checkAgents(checkOptions);
+      results.summary.checkSuccessful = results.check.summary?.allSuccessful || false;
+      results.summary.agentsChecked = results.check.totalAgents || 0;
+
+      results.summary.totalDuration = Date.now() - startTime;
+
+      return {
+        success: results.summary.discoverySuccessful && results.summary.checkSuccessful,
+        ...results,
+        message: `Completed: ${results.summary.newAgentsDiscovered} new agents discovered, ${results.summary.agentsChecked} agents checked`
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Check agents with discovery failed', { error: error.message });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        message: 'Check agents with discovery failed'
+      };
+    }
+  }
+
+  /**
+   * Get service information
+   * @returns {Object} - Service info
+   */
+  getServiceInfo() {
+    return {
+      parallel: this.parallel,
+      maxConcurrency: this.maxConcurrency,
+      timeout: this.timeout,
+      forceReinstall: this.forceReinstall,
+      skipVerification: this.skipVerification,
+      phases: [
+        {
+          name: 'Installation',
+          description: 'Install agents using available installers',
+          service: 'AgentInstallationService'
+        },
+        {
+          name: 'Verification',
+          description: 'Verify installed agents using configured tests',
+          service: 'AgentVerificationService'
+        }
+      ],
+      features: [
+        'two-phase operation (install + verify)',
+        'parallel processing',
+        'error handling',
+        'status tracking',
+        'detailed logging',
+        'progress reporting'
+      ],
+      limitations: [
+        'depends on external installers',
+        'verification test availability',
+        'timeout affects all phases',
+        'network dependency'
+      ]
+    };
+  }
+
+  /**
+   * Create check service with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {AgentCheckService} - Service instance
+   */
+  static createDefault(config = {}) {
+    return new AgentCheckService({
+      parallel: true,
+      maxConcurrency: 2,
+      timeout: 600000,
+      forceReinstall: false,
+      skipVerification: false,
+      ...config
+    });
+  }
+
+  /**
+   * Create check service for sequential execution
+   * @param {Object} config - Configuration overrides
+   * @returns {AgentCheckService} - Sequential service instance
+   */
+  static createSequential(config = {}) {
+    return new AgentCheckService({
+      parallel: false,
+      maxConcurrency: 1,
+      timeout: 900000, // Longer timeout for sequential
+      forceReinstall: false,
+      skipVerification: false,
+      ...config
+    });
+  }
+}
+
+module.exports = AgentCheckService;