vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/windows/BaseWindowsInstaller.js

@@ -0,0 +1,441 @@
+/**
+ * Base Windows Installer Interface
+ * 
+ * Abstract base class for Windows installers.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { InstallationType } = require('../InstallationType');
+const { OperationType, OperationStatus } = require('../OperationTypes');
+
+/**
+ * Abstract base class for Windows installers
+ */
+class BaseWindowsInstaller {
+  /**
+   * Create installer instance
+   * @param {Object} config - Installer configuration
+   * @param {string} config.type - Installation type
+   * @param {string} config.command - Installation command
+   * @param {string} config.packageId - Package identifier
+   * @param {number} config.priority - Priority order
+   * @param {string[]} config.requirements - System requirements
+   * @param {string} config.verificationCommand - Verification command
+   * @param {AgentLogger} config.logger - Logger instance
+   */
+  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.logger = config.logger;
+    
+    this.validate();
+  }
+
+  /**
+   * Validate installer configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validate() {
+    if (!this.type || typeof this.type !== 'string') {
+      throw new Error('Installer must have a valid 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('Installer must have a valid command');
+    }
+    
+    if (!this.verificationCommand || typeof this.verificationCommand !== 'string') {
+      throw new Error('Installer must have a verification command');
+    }
+    
+    if (!Array.isArray(this.requirements)) {
+      throw new Error('Requirements must be an array');
+    }
+  }
+
+  /**
+   * Check if installer is available on current system
+   * @returns {Promise<boolean>} - True if available
+   */
+  async isAvailable() {
+    throw new Error('isAvailable() must be implemented by subclass');
+  }
+
+  /**
+   * Check system requirements
+   * @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) {
+    if (this.logger) {
+      await this.logger.debug(`Checking requirement: ${requirement}`);
+    }
+
+    try {
+      switch (requirement.toLowerCase()) {
+        case 'windows':
+          return process.platform === 'win32';
+        case 'node.js':
+        case 'nodejs':
+          return await this.checkNodeJS();
+        case 'git':
+          return await this.checkGit();
+        case 'powershell':
+          return await this.checkPowerShell();
+        case 'winget':
+          return await this.checkWinget();
+        case 'npm':
+          return await this.checkNpm();
+        case 'chocolatey':
+        case 'choco':
+          return await this.checkChocolatey();
+        default:
+          if (this.logger) {
+            await this.logger.warn(`Unknown requirement: ${requirement}`);
+          }
+          return true; // Assume unknown requirements are met
+      }
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Error checking requirement ${requirement}: ${error.message}`);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check if Node.js is available
+   * @returns {Promise<boolean>}
+   */
+  async checkNodeJS() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('node --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if Git is available
+   * @returns {Promise<boolean>}
+   */
+  async checkGit() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('git --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if PowerShell is available
+   * @returns {Promise<boolean>}
+   */
+  async checkPowerShell() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('powershell -Command "Get-Host"', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if WinGet is available
+   * @returns {Promise<boolean>}
+   */
+  async checkWinget() {
+    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 checkNpm() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('npm --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if Chocolatey is available
+   * @returns {Promise<boolean>}
+   */
+  async checkChocolatey() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('choco --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Install agent
+   * @param {Object} options - Installation options
+   * @param {boolean} options.force - Force reinstall
+   * @param {number} options.timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async install(options = {}) {
+    const { force = false, timeout = 300000 } = options; // 5 minute default
+    
+    if (this.logger) {
+      await this.logger.info(`Starting installation using ${this.type}`, {
+        type: this.type,
+        packageId: this.packageId,
+        force
+      });
+    }
+
+    try {
+      // Check availability
+      if (!await this.isAvailable()) {
+        throw new Error(`Installation method ${this.type} is not available on this system`);
+      }
+
+      // Check requirements
+      const requirementsResult = await this.checkRequirements();
+      if (!requirementsResult.allMet) {
+        const unmet = requirementsResult.requirements
+          .filter(req => !req.met)
+          .map(req => req.requirement);
+        
+        throw new Error(`Unmet requirements: ${unmet.join(', ')}`);
+      }
+
+      // Perform installation
+      const result = await this.performInstallation(force, timeout);
+      
+      if (this.logger) {
+        await this.logger.info(`Installation completed using ${this.type}`, {
+          type: this.type,
+          packageId: this.packageId,
+          success: result.success,
+          duration: result.duration
+        });
+      }
+
+      return result;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Installation failed using ${this.type}`, {
+          type: this.type,
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Perform the actual installation
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async performInstallation(force, timeout) {
+    throw new Error('performInstallation() must be implemented by subclass');
+  }
+
+  /**
+   * Verify installation
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify() {
+    if (this.logger) {
+      await this.logger.info(`Verifying installation using ${this.type}`, {
+        type: this.type,
+        packageId: this.packageId
+      });
+    }
+
+    try {
+      const result = await this.performVerification();
+      
+      if (this.logger) {
+        await this.logger.info(`Verification completed using ${this.type}`, {
+          type: this.type,
+          packageId: this.packageId,
+          success: result.success,
+          duration: result.duration
+        });
+      }
+
+      return result;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Verification failed using ${this.type}`, {
+          type: this.type,
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Perform the actual verification
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    return await this.executeCommand(this.verificationCommand, 30000); // 30 second timeout
+  }
+
+  /**
+   * 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(`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: stdout.trim(),
+          stderr: stderr.trim(),
+          duration,
+          command
+        });
+      });
+      
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Get installer information
+   * @returns {Object} - Installer information
+   */
+  getInfo() {
+    return {
+      type: this.type,
+      packageId: this.packageId,
+      priority: this.priority,
+      requirements: this.requirements,
+      verificationCommand: this.verificationCommand,
+      command: this.command
+    };
+  }
+
+  /**
+   * Create installer instance from configuration
+   * @param {Object} config - Configuration object
+   * @param {AgentLogger} logger - Logger instance
+   * @returns {BaseWindowsInstaller} - Installer instance
+   */
+  static fromConfig(config, logger = null) {
+    const installerConfig = {
+      ...config,
+      logger
+    };
+    
+    // Return appropriate installer subclass based on type
+    switch (config.type) {
+      case InstallationType.WINGET:
+        const WinGetInstaller = require('./WinGetInstaller');
+        return new WinGetInstaller(installerConfig);
+      case InstallationType.POWERSHELL:
+        const PowerShellInstaller = require('./PowerShellInstaller');
+        return new PowerShellInstaller(installerConfig);
+      case InstallationType.NPM:
+        const NpmInstaller = require('./NpmInstaller');
+        return new NpmInstaller(installerConfig);
+      case InstallationType.CHOCOLATEY:
+        const ChocolateyInstaller = require('./ChocolateyInstaller');
+        return new ChocolateyInstaller(installerConfig);
+      case InstallationType.DIRECT:
+        const DirectInstaller = require('./DirectInstaller');
+        return new DirectInstaller(installerConfig);
+      default:
+        throw new Error(`Unknown installer type: ${config.type}`);
+    }
+  }
+}
+
+module.exports = BaseWindowsInstaller;