vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/InstallationMethod.js

@@ -0,0 +1,510 @@
+/**
+ * Installation Method Class
+ *
+ * Represents a way to install an agent on Windows.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { InstallationType } = require('./InstallationType');
+
+/**
+ * Installation method class for AI agents
+ */
+class InstallationMethod {
+  /**
+   * Create a new InstallationMethod instance
+   * @param {Object} config - Installation method configuration
+   * @param {string} config.type - Installation type (WINGET, NPM, POWERSHELL, etc.)
+   * @param {string} config.command - Installation command template
+   * @param {string} config.packageId - Package identifier for package managers
+   * @param {number} config.priority - Priority order (1 = highest)
+   * @param {string[]} config.requirements - System requirements
+   * @param {string} config.verificationCommand - Command to verify installation
+   * @param {number} config.timeout - Installation timeout in milliseconds
+   */
+  constructor(config = {}) {
+    this.type = config.type || '';
+    this.command = config.command || '';
+    this.packageId = config.packageId || '';
+    this.priority = config.priority || 999;
+    this.requirements = config.requirements || [];
+    this.verificationCommand = config.verificationCommand || '';
+    this.timeout = config.timeout || 30000; // Default 30 seconds
+
+    this.validate();
+  }
+
+  /**
+   * Validate installation method configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.type || typeof this.type !== 'string') {
+      throw new Error('Installation method must have a valid non-empty string type');
+    }
+
+    if (!Object.values(InstallationType).includes(this.type)) {
+      throw new Error(`Invalid installation type: ${this.type}`);
+    }
+
+    if (!this.command || typeof this.command !== 'string') {
+      throw new Error('Installation method must have a valid non-empty string command');
+    }
+
+    if (typeof this.priority !== 'number' || this.priority < 1) {
+      throw new Error('Priority must be a positive number');
+    }
+
+    // Package ID is required for package manager types
+    const packageManagerTypes = [InstallationType.WINGET, InstallationType.NPM, InstallationType.CHOCOLATEY];
+    if (packageManagerTypes.includes(this.type) && !this.packageId) {
+      throw new Error(`Package ID is required for ${this.type} installation type`);
+    }
+
+    if (!this.verificationCommand || typeof this.verificationCommand !== 'string') {
+      throw new Error('Installation method must have a valid non-empty string verification command');
+    }
+
+    if (!Array.isArray(this.requirements)) {
+      throw new Error('Requirements must be an array');
+    }
+
+    if (typeof this.timeout !== 'number' || this.timeout < 1000) {
+      throw new Error('Timeout must be a number greater than or equal to 1000ms');
+    }
+  }
+
+  /**
+   * Check if this installation method is available on the current system
+   * @returns {Promise<boolean>} - True if available
+   */
+  async isAvailable() {
+    try {
+      switch (this.type) {
+        case InstallationType.WINGET:
+          return await this.checkWingetAvailable();
+        case InstallationType.NPM:
+          return await this.checkNpmAvailable();
+        case InstallationType.YARN:
+          return await this.checkYarnAvailable();
+        case InstallationType.HOMEBREW:
+          return await this.checkHomebrewAvailable();
+        case InstallationType.GO:
+          return await this.checkGoAvailable();
+        case InstallationType.DIRECT:
+          return await this.checkDirectAvailable();
+        case InstallationType.POWERSHELL:
+          return await this.checkPowerShellAvailable();
+        case InstallationType.CHOCOLATEY:
+          return await this.checkChocolateyAvailable();
+        default:
+          return false;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if WinGet is available
+   * @returns {Promise<boolean>}
+   */
+  async checkWingetAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('winget --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if npm is available
+   * @returns {Promise<boolean>}
+   */
+  async checkNpmAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('npm --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if yarn is available
+   * @returns {Promise<boolean>}
+   */
+  async checkYarnAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('yarn --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if Homebrew is available
+   * @returns {Promise<boolean>}
+   */
+  async checkHomebrewAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('brew --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if Go is available
+   * @returns {Promise<boolean>}
+   */
+  async checkGoAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('go version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if direct installation is available
+   * @returns {Promise<boolean>}
+   */
+  async checkDirectAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('curl --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if PowerShell is available
+   * @returns {Promise<boolean>}
+   */
+  async checkPowerShellAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('powershell -Command "Get-Host"', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if Chocolatey is available
+   * @returns {Promise<boolean>}
+   */
+  async checkChocolateyAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('choco --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Execute the installation command
+   * @param {Object} options - Installation options
+   * @param {boolean} options.force - Force reinstall even if already installed
+   * @param {number} options.timeout - Command timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async install(options = {}) {
+    const { force = false, timeout = 300000 } = options; // 5 minute default timeout
+
+    if (!await this.isAvailable()) {
+      throw new Error(`Installation method ${this.type} is not available on this system`);
+    }
+
+    const command = this.buildInstallCommand(force);
+
+    return await this.executeCommand(command, timeout);
+  }
+
+  /**
+   * Build installation command with options
+   * @param {boolean} force - Force reinstall
+   * @returns {string} - Complete command
+   */
+  buildInstallCommand(force) {
+    let command = this.command;
+
+    // Add force flag if supported
+    if (force) {
+      switch (this.type) {
+        case InstallationType.WINGET:
+          command += ' --force';
+          break;
+        case InstallationType.NPM:
+          command += ' --force';
+          break;
+        case InstallationType.CHOCOLATEY:
+          command += ' --force';
+          break;
+        // PowerShell and direct downloads handle force differently
+      }
+    }
+
+    return command;
+  }
+
+  /**
+   * Execute command with timeout
+   * @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']
+      });
+
+      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(`Installation command timed out after ${timeout}ms`));
+      }, timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+
+        const duration = Date.now() - startTime;
+
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout,
+          stderr,
+          duration,
+          command
+        });
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Verify installation using verification command
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify() {
+    try {
+      const result = await this.executeCommand(this.verificationCommand, 30000); // 30 second timeout
+      return {
+        success: result.success,
+        output: result.stdout,
+        error: result.stderr,
+        duration: result.duration
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        duration: 0
+      };
+    }
+  }
+
+  /**
+   * Check if system requirements are met
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const results = {
+      allMet: true,
+      requirements: []
+    };
+
+    for (const requirement of this.requirements) {
+      const met = await this.checkSingleRequirement(requirement);
+      results.requirements.push({
+        requirement,
+        met
+      });
+
+      if (!met) {
+        results.allMet = false;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check a single system requirement
+   * @param {string} requirement - Requirement to check
+   * @returns {Promise<boolean>} - True if requirement is met
+   */
+  async checkSingleRequirement(requirement) {
+    // Common requirement checks
+    switch (requirement.toLowerCase()) {
+      case 'windows':
+        return process.platform === 'win32';
+      case 'node.js':
+      case 'nodejs':
+        try {
+          const { execSync } = require('child_process');
+          execSync('node --version', { stdio: 'ignore' });
+          return true;
+        } catch {
+          return false;
+        }
+      case 'git':
+        try {
+          const { execSync } = require('child_process');
+          execSync('git --version', { stdio: 'ignore' });
+          return true;
+        } catch {
+          return false;
+        }
+      case 'powershell':
+        return await this.checkPowerShellAvailable();
+      default:
+        // For unknown requirements, assume they're met
+        return true;
+    }
+  }
+
+  /**
+   * Convert installation method to plain object
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      command: this.command,
+      packageId: this.packageId,
+      priority: this.priority,
+      requirements: [...this.requirements],
+      verificationCommand: this.verificationCommand
+    };
+  }
+
+  /**
+   * Create installation method from plain object data
+   * @param {Object} data - Plain object data
+   * @returns {InstallationMethod}
+   */
+  static fromJSON(data) {
+    // Convert lowercase type to uppercase enum value
+    const normalizedData = {
+      ...data,
+      type: data.type ? data.type.toUpperCase() : data.type
+    };
+    
+    return new InstallationMethod(normalizedData);
+  }
+
+  /**
+   * Create common installation methods for known agents
+   * @param {string} agentId - Agent identifier
+   * @param {string} type - Installation type
+   * @returns {InstallationMethod|null}
+   */
+  static createCommonMethod(agentId, type) {
+    const methods = {
+      'claude-code': {
+        [InstallationType.POWERSHELL]: {
+          command: 'irm https://claude.ai/install.ps1 | iex',
+          packageId: '',
+          priority: 1,
+          requirements: ['powershell', 'windows'],
+          verificationCommand: 'claude --version'
+        },
+        [InstallationType.WINGET]: {
+          command: 'winget install Anthropic.ClaudeCode',
+          packageId: 'Anthropic.ClaudeCode',
+          priority: 2,
+          requirements: ['windows'],
+          verificationCommand: 'claude --version'
+        }
+      },
+      'github-copilot': {
+        [InstallationType.WINGET]: {
+          command: 'winget install GitHub.Copilot',
+          packageId: 'GitHub.Copilot',
+          priority: 1,
+          requirements: ['windows'],
+          verificationCommand: 'gh copilot --version'
+        },
+        [InstallationType.NPM]: {
+          command: 'npm install -g @github/copilot',
+          packageId: '@github/copilot',
+          priority: 2,
+          requirements: ['node.js'],
+          verificationCommand: 'gh copilot --version'
+        }
+      },
+      'gemini-cli': {
+        [InstallationType.NPM]: {
+          command: 'npm install -g @google/gemini-cli',
+          packageId: '@google/gemini-cli',
+          priority: 1,
+          requirements: ['node.js'],
+          verificationCommand: 'gemini --version'
+        }
+      }
+    };
+
+    const agentMethods = methods[agentId];
+    if (!agentMethods || !agentMethods[type]) {
+      return null;
+    }
+
+    return new InstallationMethod({
+      type,
+      ...agentMethods[type]
+    });
+  }
+
+  /**
+   * Convert installation method to JSON representation
+   * @returns {Object} Plain object representation
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      command: this.command,
+      packageId: this.packageId,
+      priority: this.priority,
+      requirements: this.requirements,
+      verificationCommand: this.verificationCommand
+    };
+  }
+}
+
+module.exports = InstallationMethod;