vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/verification/CommandVerifier.js

@@ -0,0 +1,480 @@
+/**
+ * Command Execution Verifier
+ * 
+ * Command execution verification implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseVerifier = require('./BaseVerifier');
+const { VerificationType } = require('../VerificationType');
+
+/**
+ * Command execution verifier class
+ */
+class CommandVerifier extends BaseVerifier {
+  /**
+   * Create command execution verifier instance
+   * @param {Object} config - Verifier configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: VerificationType.COMMAND_EXECUTION,
+      description: 'Basic command execution test',
+      command: config.command || '{agentCommand} --version',
+      expectedResult: config.expectedResult || 'version',
+      timeout: config.timeout || 15,
+      ...config
+    });
+    
+    this.agentCommand = config.agentCommand || '';
+    this.versionFlag = config.versionFlag || '--version';
+    this.helpFlag = config.helpFlag || '--help';
+    this.testCommand = config.testCommand || '';
+  }
+
+  /**
+   * Execute command verification
+   * @param {Object} options - Verification options
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify(options = {}) {
+    const { context = {} } = options;
+    
+    if (this.logger) {
+      await this.logger.info('Starting command execution verification', {
+        agentCommand: this.agentCommand,
+        testCommand: this.testCommand,
+        context
+      });
+    }
+
+    const startTime = Date.now();
+    
+    try {
+      // Build test command
+      const testCommand = this.buildTestCommand(context);
+      
+      // Execute command
+      const result = await this.executeCommand(testCommand, this.timeout * 1000);
+      
+      // Evaluate result
+      const passed = this.evaluateResult(result);
+      
+      const verificationResult = {
+        id: this.generateId(),
+        agentId: options.agentId || '',
+        type: this.type,
+        description: this.description,
+        passed,
+        command: testCommand,
+        result,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString(),
+        agentCommand: this.agentCommand,
+        versionFlag: this.versionFlag
+      };
+
+      if (this.logger) {
+        const level = passed ? 'info' : 'warn';
+        const message = passed 
+          ? 'Command execution verification passed'
+          : 'Command execution verification failed';
+        
+        await this.logger[level](message, {
+          agentId: options.agentId,
+          agentCommand: this.agentCommand,
+          passed,
+          duration: verificationResult.duration,
+          exitCode: result.exitCode
+        });
+      }
+
+      return verificationResult;
+    } catch (error) {
+      const errorResult = {
+        id: this.generateId(),
+        agentId: options.agentId || '',
+        type: this.type,
+        description: this.description,
+        passed: false,
+        error: error.message,
+        duration: Date.now() - startTime,
+        timeout: this.timeout * 1000,
+        timestamp: new Date().toISOString(),
+        agentCommand: this.agentCommand
+      };
+
+      if (this.logger) {
+        await this.logger.error('Command execution verification error', {
+          agentId: options.agentId,
+          agentCommand: this.agentCommand,
+          error: error.message,
+          duration: errorResult.duration
+        });
+      }
+
+      return errorResult;
+    }
+  }
+
+  /**
+   * Build test command with context
+   * @param {Object} context - Test context
+   * @returns {string} - Test command
+   */
+  buildTestCommand(context) {
+    let command = this.command;
+    
+    // Replace common placeholders
+    Object.entries(context).forEach(([key, value]) => {
+      const placeholder = `{${key}}`;
+      command = command.replace(new RegExp(placeholder, 'g'), value);
+    });
+    
+    return command;
+  }
+
+  /**
+   * Execute command with enhanced error handling
+   * @param {string} command - Command to execute
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Execution result
+   */
+  async executeCommand(command, timeout) {
+    return new Promise((resolve, reject) => {
+      const { spawn } = require('child_process');
+      
+      const startTime = Date.now();
+      const child = spawn(command, [], { 
+        shell: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Command execution timed out after ${timeout}ms`));
+      }, timeout);
+      
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        
+        const duration = Date.now() - startTime;
+        
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          duration,
+          command
+        });
+      });
+      
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Evaluate command execution result
+   * @param {Object} result - Command result
+   * @returns {boolean} - True if verification passed
+   */
+  evaluateResult(result) {
+    // Basic success check - command should exit with code 0
+    if (!result.success) {
+      return false;
+    }
+
+    // Check for expected result in output
+    if (this.expectedResult) {
+      const output = result.stdout.toLowerCase();
+      const expected = this.expectedResult.toLowerCase();
+      
+      if (expected !== 'any' && !output.includes(expected)) {
+        return false;
+      }
+    }
+
+    // Additional checks based on command type
+    return this.performAdditionalChecks(result);
+  }
+
+  /**
+   * Perform additional verification checks
+   * @param {Object} result - Command result
+   * @returns {boolean} - True if additional checks pass
+   */
+  performAdditionalChecks(result) {
+    // Check for common error indicators
+    const errorIndicators = [
+      'command not found',
+      'not recognized',
+      'permission denied',
+      'access denied',
+      'no such file',
+      'file not found',
+      'error:',
+      'failed',
+      'unable to'
+    ];
+
+    const output = result.stdout.toLowerCase() + ' ' + result.stderr.toLowerCase();
+    
+    for (const indicator of errorIndicators) {
+      if (output.includes(indicator)) {
+        return false;
+      }
+    }
+
+    // Check for version-like output
+    const versionPatterns = [
+      /\d+\.\d+\.\d+/, // x.y.z
+      /\d+\.\d+/, // x.y
+      /v\d+\.\d+\.\d+/, // vx.y.z
+      /version \d+/, // version x
+      /\d+\.\d+\.\d+-\w+/, // x.y.z-beta
+    ];
+
+    const hasVersionOutput = versionPatterns.some(pattern => 
+      pattern.test(result.stdout) || pattern.test(result.stderr)
+    );
+
+    return hasVersionOutput || result.success;
+  }
+
+  /**
+   * Test command availability
+   * @param {string} command - Command to test
+   * @returns {Promise<boolean>} - True if command is available
+   */
+  async testCommandAvailability(command) {
+    try {
+      const result = await this.executeCommand(`${command} --version`, 5000);
+      return result.success;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get command version information
+   * @param {string} command - Command to check
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getCommandVersion(command) {
+    try {
+      const result = await this.executeCommand(`${command} --version`, 10000);
+      
+      if (result.success) {
+        // Parse version from output
+        const lines = result.stdout.split('\n');
+        const versionLine = lines.find(line => 
+          line.toLowerCase().includes('version') || 
+          /\d+\.\d+\.\d+/.test(line)
+        );
+        
+        if (versionLine) {
+          const match = versionLine.match(/(\d+\.\d+\.\d+)/);
+          return match ? match[1] : null;
+        }
+      }
+      
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Test command with different flags
+   * @param {string} command - Base command
+   * @param {Array<string>} flags - Flags to test
+   * @returns {Promise<Object>} - Test results
+   */
+  async testCommandFlags(command, flags) {
+    const results = {};
+    
+    for (const flag of flags) {
+      try {
+        const testCommand = `${command} ${flag}`;
+        const result = await this.executeCommand(testCommand, 10000);
+        results[flag] = {
+          success: result.success,
+          output: result.stdout,
+          error: result.stderr
+        };
+      } catch (error) {
+        results[flag] = {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Check if command is installed in PATH
+   * @param {string} command - Command to check
+   * @returns {Promise<boolean>} - True if command is in PATH
+   */
+  async isCommandInPath(command) {
+    try {
+      const { execSync } = require('child_process');
+      
+      // Use 'where' on Windows, 'which' on Unix-like systems
+      const checkCommand = process.platform === 'win32' ? `where ${command}` : `which ${command}`;
+      
+      execSync(checkCommand, { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get command help information
+   * @param {string} command - Command to get help for
+   * @returns {Promise<string|null>} - Help output or null
+   */
+  async getCommandHelp(command) {
+    try {
+      const helpCommand = `${command} ${this.helpFlag}`;
+      const result = await this.executeCommand(helpCommand, 15000);
+      
+      return result.success ? result.stdout : null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Validate command syntax
+   * @param {string} command - Command to validate
+   * @returns {Object} - Validation result
+   */
+  validateCommandSyntax(command) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    // Check for dangerous commands
+    const dangerousCommands = [
+      'rm -rf /',
+      'del /s /q',
+      'format',
+      'fdisk',
+      'shutdown',
+      'reboot'
+    ];
+
+    const commandLower = command.toLowerCase();
+    for (const dangerous of dangerousCommands) {
+      if (commandLower.includes(dangerous)) {
+        result.valid = false;
+        result.errors.push(`Potentially dangerous command detected: ${dangerous}`);
+      }
+    }
+
+    // Check for command injection patterns
+    const injectionPatterns = [
+      /&&\s*rm/,
+      /\|\s*del/,
+      /;\s*format/,
+      /`.*rm/,
+      /\$\(.*del/
+    ];
+
+    for (const pattern of injectionPatterns) {
+      if (pattern.test(command)) {
+        result.valid = false;
+        result.errors.push('Potential command injection detected');
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get command execution verifier information
+   * @returns {Object} - Verifier info
+   */
+  getVerifierInfo() {
+    return {
+      ...this.getInfo(),
+      type: VerificationType.COMMAND_EXECUTION,
+      supportedPlatforms: ['win32', 'darwin', 'linux'],
+      requirements: [
+        'command line access',
+        'agent installation',
+        'execution permissions'
+      ],
+      features: [
+        'command execution',
+        'version checking',
+        'help support',
+        'error detection',
+        'syntax validation'
+      ],
+      limitations: [
+        'requires agent installation',
+        'command dependent',
+        'platform specific',
+        'permission dependent'
+      ]
+    };
+  }
+
+  /**
+   * Create command execution verifier from configuration
+   * @param {Object} config - Configuration object
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {CommandVerifier} - Verifier instance
+   */
+  static fromConfig(config, logger = null) {
+    return new CommandVerifier({
+      ...config,
+      logger
+    });
+  }
+
+  /**
+   * Create default command execution verifier
+   * @param {string} agentId - Agent identifier
+   * @param {string} agentCommand - Agent command
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {CommandVerifier} - Default verifier instance
+   */
+  static createDefault(agentId, agentCommand, logger = null) {
+    return new CommandVerifier({
+      id: `${agentId}-cmd-exec`,
+      agentId,
+      command: `${agentCommand} --version`,
+      expectedResult: 'version',
+      timeout: 15,
+      agentCommand,
+      logger
+    });
+  }
+}
+
+module.exports = CommandVerifier;