vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/windows/PowerShellInstaller.js

@@ -0,0 +1,458 @@
+/**
+ * PowerShell Installer
+ * 
+ * PowerShell script-based installer implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseWindowsInstaller = require('./BaseWindowsInstaller');
+const { InstallationType } = require('../InstallationType');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * PowerShell installer class for Windows agents
+ */
+class PowerShellInstaller extends BaseWindowsInstaller {
+  /**
+   * Create PowerShell installer instance
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.POWERSHELL,
+      ...config
+    });
+    
+    this.scriptPath = config.scriptPath || '';
+    this.executionPolicy = config.executionPolicy || 'RemoteSigned';
+    this.tempDir = path.join(os.tmpdir(), 'vibe-coding-machine');
+  }
+
+  /**
+   * Check if PowerShell is available on current system
+   * @returns {Promise<boolean>} - True if PowerShell is available
+   */
+  async isAvailable() {
+    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 system requirements for PowerShell
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const requirements = await super.checkRequirements();
+    
+    // PowerShell-specific requirements
+    const psRequirements = [
+      { requirement: 'windows', met: process.platform === 'win32' },
+      { requirement: 'powershell', met: await this.isAvailable() },
+      { requirement: 'execution-policy', met: await this.checkExecutionPolicy() }
+    ];
+
+    psRequirements.forEach(req => {
+      requirements.requirements.push(req);
+      if (!req.met) {
+        requirements.allMet = false;
+      }
+    });
+
+    return requirements;
+  }
+
+  /**
+   * Check PowerShell execution policy
+   * @returns {Promise<boolean>} - True if execution policy allows scripts
+   */
+  async checkExecutionPolicy() {
+    try {
+      const { execSync } = require('child_process');
+      const output = execSync('powershell -Command "Get-ExecutionPolicy"', { encoding: 'utf8' });
+      
+      // Check if execution policy allows script execution
+      const allowedPolicies = ['RemoteSigned', 'Unrestricted', 'Bypass', 'AllSigned'];
+      const currentPolicy = output.trim();
+      
+      return allowedPolicies.includes(currentPolicy);
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Failed to check execution policy', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Perform actual installation using PowerShell
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async performInstallation(force, timeout) {
+    const command = await this.buildInstallCommand(force);
+    
+    if (this.logger) {
+      await this.logger.info('Installing with PowerShell', {
+        scriptPath: this.scriptPath,
+        command,
+        force
+      });
+    }
+
+    try {
+      // Ensure temp directory exists
+      await fs.mkdir(this.tempDir, { recursive: true });
+      
+      const result = await this.executeCommand(command, timeout);
+      
+      if (this.logger) {
+        await this.logger.info('PowerShell installation completed', {
+          scriptPath: this.scriptPath,
+          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: 'powershell'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('PowerShell installation failed', {
+          scriptPath: this.scriptPath,
+          error: error.message,
+          command
+        });
+      }
+      throw error;
+    } finally {
+      // Cleanup temp directory
+      try {
+        await fs.rmdir(this.tempDir, { recursive: true });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Build PowerShell install command
+   * @param {boolean} force - Force reinstall
+   * @returns {Promise<string>} - PowerShell command
+   */
+  async buildInstallCommand(force) {
+    let command = 'powershell -ExecutionPolicy Bypass';
+    
+    if (this.scriptPath) {
+      // Use provided script file
+      if (this.scriptPath.startsWith('http')) {
+        // Download and execute remote script
+        command += ` -Command "Invoke-WebRequest -Uri '${this.scriptPath}' -OutFile '$env:TEMP\\install.ps1'; & '$env:TEMP\\install.ps1'"`;
+      } else {
+        // Execute local script
+        command += ` -File "${this.scriptPath}"`;
+      }
+    } else {
+      // Use command directly
+      command += ` -Command "${this.command}"`;
+    }
+    
+    // Add force parameter if requested
+    if (force) {
+      command += ' -Force';
+    }
+    
+    return command;
+  }
+
+  /**
+   * Perform verification using PowerShell
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    try {
+      if (!this.verificationCommand) {
+        return {
+          success: false,
+          error: 'No verification command specified',
+          installer: 'powershell'
+        };
+      }
+
+      const command = `powershell -ExecutionPolicy Bypass -Command "${this.verificationCommand}"`;
+      
+      if (this.logger) {
+        await this.logger.debug('Verifying with PowerShell', {
+          verificationCommand: this.verificationCommand,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 30000);
+      
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        installer: 'powershell',
+        verified: result.success
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('PowerShell verification failed', {
+          verificationCommand: this.verificationCommand,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Download and execute remote PowerShell script
+   * @param {string} scriptUrl - URL of the script
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async downloadAndExecute(scriptUrl, force, timeout) {
+    try {
+      if (this.logger) {
+        await this.logger.info('Downloading PowerShell script', { scriptUrl });
+      }
+
+      // Download script to temp location
+      const scriptContent = await this.downloadScript(scriptUrl);
+      const tempScriptPath = path.join(this.tempDir, 'install.ps1');
+      
+      await fs.writeFile(tempScriptPath, scriptContent, 'utf8');
+      
+      // Execute downloaded script
+      const command = `powershell -ExecutionPolicy Bypass -File "${tempScriptPath}"`;
+      if (force) {
+        command += ' -Force';
+      }
+      
+      const result = await this.executeCommand(command, timeout);
+      
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        duration: result.duration,
+        command,
+        installer: 'powershell'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to download and execute script', {
+          scriptUrl,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Download PowerShell script from URL
+   * @param {string} url - Script URL
+   * @returns {Promise<string>} - Script content
+   */
+  async downloadScript(url) {
+    const https = require('https');
+    const http = require('http');
+    const client = url.startsWith('https') ? https : http;
+    
+    return new Promise((resolve, reject) => {
+      client.get(url, (response) => {
+        let data = '';
+        
+        response.on('data', (chunk) => {
+          data += chunk;
+        });
+        
+        response.on('end', () => {
+          if (response.statusCode === 200) {
+            resolve(data);
+          } else {
+            reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+          }
+        });
+      }).on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Check if PowerShell script exists and is accessible
+   * @returns {Promise<boolean>} - True if script is accessible
+   */
+  async checkScriptAccess() {
+    try {
+      if (!this.scriptPath) {
+        return false;
+      }
+
+      if (this.scriptPath.startsWith('http')) {
+        // Check remote script accessibility
+        await this.downloadScript(this.scriptPath);
+        return true;
+      } else {
+        // Check local script accessibility
+        await fs.access(this.scriptPath);
+        return true;
+      }
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Script not accessible', {
+          scriptPath: this.scriptPath,
+          error: error.message
+        });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Get installed version using PowerShell
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getInstalledVersion() {
+    try {
+      if (!this.verificationCommand) {
+        return null;
+      }
+
+      const command = `powershell -ExecutionPolicy Bypass -Command "${this.verificationCommand}"`;
+      const result = await this.executeCommand(command, 30000);
+      
+      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) {
+      if (this.logger) {
+        await this.logger.debug('Failed to get installed version', {
+          verificationCommand: this.verificationCommand,
+          error: error.message
+        });
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Uninstall using PowerShell
+   * @returns {Promise<Object>} - Uninstallation result
+   */
+  async uninstall() {
+    try {
+      // For PowerShell, we typically need a specific uninstall script
+      if (!this.uninstallCommand) {
+        return {
+          success: false,
+          error: 'No uninstall command specified for PowerShell installer',
+          installer: 'powershell'
+        };
+      }
+
+      const command = `powershell -ExecutionPolicy Bypass -Command "${this.uninstallCommand}"`;
+      
+      if (this.logger) {
+        await this.logger.info('Uninstalling with PowerShell', {
+          uninstallCommand: this.uninstallCommand,
+          command
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('PowerShell uninstallation completed', {
+          uninstallCommand: this.uninstallCommand,
+          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: 'powershell'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('PowerShell uninstallation failed', {
+          uninstallCommand: this.uninstallCommand,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get PowerShell-specific information
+   * @returns {Object} - PowerShell installer info
+   */
+  getInstallerInfo() {
+    return {
+      ...this.getInfo(),
+      installer: 'powershell',
+      supportedPlatforms: ['win32'],
+      minimumWindowsVersion: '7.0',
+      supportedArchitectures: ['x64', 'arm64'],
+      features: [
+        'script execution',
+        'remote script support',
+        'execution policy control',
+        'temp directory management'
+      ],
+      limitations: [
+        'Windows only',
+        'execution policy restrictions',
+        'requires script availability',
+        'security restrictions'
+      ]
+    };
+  }
+}
+
+module.exports = PowerShellInstaller;