vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/windows/ChocolateyInstaller.js

@@ -0,0 +1,509 @@
+/**
+ * Chocolatey Installer
+ * 
+ * Chocolatey package manager installer implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseWindowsInstaller = require('./BaseWindowsInstaller');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * Chocolatey installer class for Windows agents
+ */
+class ChocolateyInstaller extends BaseWindowsInstaller {
+  /**
+   * Create Chocolatey installer instance
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.CHOCOLATEY,
+      ...config
+    });
+    
+    this.source = config.source || '';
+    this.version = config.version || '';
+    this.preRelease = config.preRelease || false;
+  }
+
+  /**
+   * Check if Chocolatey is available on current system
+   * @returns {Promise<boolean>} - True if Chocolatey is available
+   */
+  async isAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('choco --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Chocolatey not available', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check system requirements for Chocolatey
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const requirements = await super.checkRequirements();
+    
+    // Chocolatey-specific requirements
+    const chocoRequirements = [
+      { requirement: 'windows', met: process.platform === 'win32' },
+      { requirement: 'chocolatey', met: await this.isAvailable() },
+      { requirement: 'internet', met: await this.checkInternetConnection() },
+      { requirement: 'powershell', met: await this.checkPowerShell() }
+    ];
+
+    chocoRequirements.forEach(req => {
+      requirements.requirements.push(req);
+      if (!req.met) {
+        requirements.allMet = false;
+      }
+    });
+
+    return requirements;
+  }
+
+  /**
+   * Check if PowerShell is available (required by Chocolatey)
+   * @returns {Promise<boolean>} - True if PowerShell is available
+   */
+  async checkPowerShell() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('powershell -Command "Get-Host"', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('PowerShell not available', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check internet connection
+   * @returns {Promise<boolean>} - True if internet is available
+   */
+  async checkInternetConnection() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('ping -n 1 chocolatey.org', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Internet connection check failed', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Perform actual installation using Chocolatey
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async performInstallation(force, timeout) {
+    const command = this.buildInstallCommand(force);
+    
+    if (this.logger) {
+      await this.logger.info('Installing with Chocolatey', {
+        packageId: this.packageId,
+        command,
+        force,
+        version: this.version,
+        preRelease: this.preRelease
+      });
+    }
+
+    try {
+      const result = await this.executeCommand(command, timeout);
+      
+      if (this.logger) {
+        await this.logger.info('Chocolatey installation completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        command,
+        installer: 'chocolatey'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Chocolatey installation failed', {
+          packageId: this.packageId,
+          error: error.message,
+          command
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Build Chocolatey install command
+   * @param {boolean} force - Force reinstall
+   * @returns {string} - Chocolatey command
+   */
+  buildInstallCommand(force) {
+    let command = 'choco install';
+    
+    // Add package name
+    command += ` ${this.packageId}`;
+    
+    // Add version if specified
+    if (this.version) {
+      command += ` --version=${this.version}`;
+    }
+    
+    // Add source if specified
+    if (this.source) {
+      command += ` --source="${this.source}"`;
+    }
+    
+    // Add pre-release flag if specified
+    if (this.preRelease) {
+      command += ' --pre';
+    }
+    
+    // Add force flag if requested
+    if (force) {
+      command += ' --force';
+    }
+    
+    // Add other useful flags
+    command += ' --yes --accept-license';
+    
+    return command;
+  }
+
+  /**
+   * Perform verification using Chocolatey
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    try {
+      // First check if package is installed using Chocolatey list
+      const listCommand = `choco list --local --exact ${this.packageId}`;
+      const listResult = await this.executeCommand(listCommand, 30000);
+      
+      if (!listResult.success) {
+        return {
+          success: false,
+          error: 'Package not found in Chocolatey list',
+          exitCode: listResult.exitCode,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'chocolatey'
+        };
+      }
+
+      // Check if package is actually installed
+      const isInstalled = listResult.stdout.includes(this.packageId) || 
+                        listResult.stdout.toLowerCase().includes(this.packageId.toLowerCase());
+
+      if (!isInstalled) {
+        return {
+          success: false,
+          error: 'Package not properly installed',
+          exitCode: 1,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'chocolatey'
+        };
+      }
+
+      // Run verification command if provided
+      if (this.verificationCommand) {
+        const verifyResult = await this.executeCommand(this.verificationCommand, 30000);
+        
+        return {
+          success: verifyResult.success,
+          exitCode: verifyResult.exitCode,
+          stdout: verifyResult.stdout,
+          stderr: verifyResult.stderr,
+          installer: 'chocolatey',
+          verified: verifyResult.success
+        };
+      }
+
+      return {
+        success: true,
+        exitCode: 0,
+        stdout: listResult.stdout,
+        stderr: '',
+        installer: 'chocolatey',
+        verified: true
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Chocolatey verification failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get installed version using Chocolatey
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getInstalledVersion() {
+    try {
+      const command = `choco list --local --exact ${this.packageId}`;
+      const result = await this.executeCommand(command, 30000);
+      
+      if (result.success) {
+        // Parse version from output
+        const lines = result.stdout.split('\n');
+        const packageLine = lines.find(line => 
+          line.toLowerCase().includes(this.packageId.toLowerCase())
+        );
+        
+        if (packageLine) {
+          // Chocolatey output format: "packageName version [installed]"
+          const match = packageLine.match(/\s+(\d+\.\d+\.\d+)\s+\[/);
+          return match ? match[1] : null;
+        }
+      }
+      
+      return null;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Failed to get installed version', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Uninstall package using Chocolatey
+   * @returns {Promise<Object>} - Uninstallation result
+   */
+  async uninstall() {
+    try {
+      const command = `choco uninstall ${this.packageId} --yes`;
+      
+      if (this.logger) {
+        await this.logger.info('Uninstalling with Chocolatey', {
+          packageId: this.packageId,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('Chocolatey uninstallation completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        installer: 'chocolatey'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Chocolatey uninstallation failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Update package using Chocolatey
+   * @returns {Promise<Object>} - Update result
+   */
+  async update() {
+    try {
+      const command = `choco upgrade ${this.packageId} --yes`;
+      
+      if (this.logger) {
+        await this.logger.info('Updating with Chocolatey', {
+          packageId: this.packageId,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('Chocolatey update completed', {
+          packageId: this.packageId,
+          success: result.success,
+          exitCode: result.exitCode,
+          duration: result.duration
+        });
+      }
+
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        installer: 'chocolatey'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Chocolatey update failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Check for package updates
+   * @returns {Promise<Object>} - Update check result
+   */
+  async checkUpdates() {
+    try {
+      const command = `choco outdated ${this.packageId}`;
+      const result = await this.executeCommand(command, 60000); // 1 minute timeout
+      
+      if (result.success && result.stdout.trim()) {
+        const lines = result.stdout.split('\n');
+        const packageLine = lines.find(line => 
+          line.toLowerCase().includes(this.packageId.toLowerCase())
+        );
+        
+        if (packageLine) {
+          // Parse Chocolatey outdated format
+          const parts = packageLine.split('|').map(part => part.trim());
+          if (parts.length >= 3) {
+            return {
+              updateAvailable: true,
+              current: parts[1],
+              latest: parts[2],
+              installer: 'chocolatey'
+            };
+          }
+        }
+      }
+      
+      return {
+        updateAvailable: false,
+        current: await this.getInstalledVersion(),
+        installer: 'chocolatey'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Failed to check for updates', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      return {
+        updateAvailable: false,
+        error: error.message,
+        installer: 'chocolatey'
+      };
+    }
+  }
+
+  /**
+   * Search for packages in Chocolatey repository
+   * @param {string} searchTerm - Search term
+   * @returns {Promise<Array>} - Array of package results
+   */
+  async searchPackages(searchTerm) {
+    try {
+      const command = `choco search ${searchTerm} --exact`;
+      const result = await this.executeCommand(command, 60000);
+      
+      if (result.success) {
+        const lines = result.stdout.split('\n');
+        const packages = [];
+        
+        for (const line of lines) {
+          if (line.trim() && !line.startsWith('Chocolatey')) {
+            const parts = line.split(' ').filter(part => part.trim());
+            if (parts.length > 0) {
+              packages.push({
+                name: parts[0],
+                description: parts.slice(1).join(' '),
+                installer: 'chocolatey'
+              });
+            }
+          }
+        }
+        
+        return packages;
+      }
+      
+      return [];
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Package search failed', {
+          searchTerm,
+          error: error.message
+        });
+      }
+      return [];
+    }
+  }
+
+  /**
+   * Get Chocolatey-specific information
+   * @returns {Object} - Chocolatey installer info
+   */
+  getInstallerInfo() {
+    return {
+      ...this.getInfo(),
+      installer: 'chocolatey',
+      supportedPlatforms: ['win32'],
+      minimumWindowsVersion: '7.0',
+      supportedArchitectures: ['x64'],
+      features: [
+        'package repository',
+        'version management',
+        'dependency resolution',
+        'update checking',
+        'package search'
+      ],
+      limitations: [
+        'Windows only',
+        'requires PowerShell',
+        'internet connection required',
+        'repository limitations',
+        'admin privileges often required'
+      ]
+    };
+  }
+}
+
+module.exports = ChocolateyInstaller;