vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/windows/DirectInstaller.js

@@ -0,0 +1,443 @@
+/**
+ * Direct Installer
+ * 
+ * Direct download and install 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');
+
+/**
+ * Direct installer class for Windows agents
+ */
+class DirectInstaller extends BaseWindowsInstaller {
+  /**
+   * Create Direct installer instance
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.DIRECT,
+      ...config
+    });
+    
+    this.downloadUrl = config.downloadUrl || '';
+    this.installScript = config.installScript || '';
+    this.extractPath = config.extractPath || '';
+    this.executablePath = config.executablePath || '';
+  }
+
+  /**
+   * Direct installer is always available (no dependencies)
+   * @returns {Promise<boolean>} - Always true
+   */
+  async isAvailable() {
+    return true; // Direct installation has no external dependencies
+  }
+
+  /**
+   * Check system requirements for direct installation
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const requirements = await super.checkRequirements();
+    
+    // Direct installation has minimal requirements
+    const directRequirements = [
+      { requirement: 'file-system', met: await this.checkFileSystem() },
+      { requirement: 'internet', met: this.downloadUrl ? await this.checkInternetConnection() : true }
+    ];
+
+    directRequirements.forEach(req => {
+      requirements.requirements.push(req);
+      if (!req.met) {
+        requirements.allMet = false;
+      }
+    });
+
+    return requirements;
+  }
+
+  /**
+   * Check if file system is accessible
+   * @returns {Promise<boolean>} - True if file system is accessible
+   */
+  async checkFileSystem() {
+    try {
+      const tempDir = os.tmpdir();
+      await fs.access(tempDir);
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('File system not accessible', { 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 google.com', { 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 direct download
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async performInstallation(force, timeout) {
+    if (this.logger) {
+      await this.logger.info('Starting direct installation', {
+        downloadUrl: this.downloadUrl,
+        command: this.command,
+        force
+      });
+    }
+
+    try {
+      let result;
+      
+      if (this.downloadUrl) {
+        // Download and install approach
+        result = await this.downloadAndInstall(force, timeout);
+      } else if (this.command) {
+        // Direct command execution approach
+        result = await this.executeCommand(this.command, timeout);
+      } else {
+        throw new Error('Direct installer requires either downloadUrl or command');
+      }
+
+      if (this.logger) {
+        await this.logger.info('Direct installation completed', {
+          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: 'direct'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Direct installation failed', {
+          downloadUrl: this.downloadUrl,
+          command: this.command,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Download and install package
+   * @param {boolean} force - Force reinstall
+   * @param {number} timeout - Timeout in milliseconds
+   * @returns {Promise<Object>} - Installation result
+   */
+  async downloadAndInstall(force, timeout) {
+    const tempDir = path.join(os.tmpdir(), 'vibe-coding-machine');
+    await fs.mkdir(tempDir, { recursive: true });
+
+    try {
+      // Download the file
+      const filePath = await this.downloadFile(this.downloadUrl, tempDir);
+      
+      // Install the downloaded file
+      const installCommand = await this.buildInstallCommand(filePath, force);
+      const result = await this.executeCommand(installCommand, timeout);
+      
+      return {
+        ...result,
+        downloadPath: filePath,
+        installer: 'direct'
+      };
+    } finally {
+      // Cleanup temp directory
+      try {
+        await fs.rmdir(tempDir, { recursive: true });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Download file from URL
+   * @param {string} url - Download URL
+   * @param {string} destDir - Destination directory
+   * @returns {Promise<string>} - Downloaded file path
+   */
+  async downloadFile(url, destDir) {
+    const https = require('https');
+    const http = require('http');
+    const client = url.startsWith('https') ? https : http;
+    
+    return new Promise((resolve, reject) => {
+      const fileName = path.basename(url) || 'download';
+      const filePath = path.join(destDir, fileName);
+      const fileStream = fs.createWriteStream(filePath);
+      
+      client.get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+          return;
+        }
+
+        response.pipe(fileStream);
+        
+        fileStream.on('finish', () => {
+          fileStream.close();
+          resolve(filePath);
+        });
+        
+        fileStream.on('error', (error) => {
+          reject(error);
+        });
+      }).on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Build install command for downloaded file
+   * @param {string} filePath - Downloaded file path
+   * @param {boolean} force - Force reinstall
+   * @returns {Promise<string>} - Install command
+   */
+  async buildInstallCommand(filePath, force) {
+    if (this.installScript) {
+      // Use custom install script
+      return this.installScript.replace('{file}', filePath).replace('{force}', force ? '--force' : '');
+    }
+
+    // Default behavior based on file extension
+    const ext = path.extname(filePath).toLowerCase();
+    
+    switch (ext) {
+      case '.exe':
+        return `"${filePath}" ${force ? '/S' : ''}`; // Silent install if force
+      
+      case '.msi':
+        return `msiexec /i "${filePath}" ${force ? '/quiet' : ''}`;
+      
+      case '.zip':
+      case '.tar':
+      case '.gz':
+        return await this.extractAndInstall(filePath, force);
+      
+      case '.ps1':
+        return `powershell -ExecutionPolicy Bypass -File "${filePath}" ${force ? '-Force' : ''}`;
+      
+      default:
+        return `"${filePath}"`;
+    }
+  }
+
+  /**
+   * Extract and install archive
+   * @param {string} archivePath - Archive file path
+   * @param {boolean} force - Force reinstall
+   * @returns {Promise<string>} - Install command
+   */
+  async extractAndInstall(archivePath, force) {
+    const extractDir = path.join(path.dirname(archivePath), 'extract');
+    await fs.mkdir(extractDir, { recursive: true });
+
+    // Use built-in Windows tar for .tar files, or assume unzip for .zip
+    const ext = path.extname(archivePath).toLowerCase();
+    let extractCommand;
+
+    if (ext === '.zip') {
+      extractCommand = `powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${extractDir}'"`;
+    } else {
+      extractCommand = `tar -xf "${archivePath}" -C "${extractDir}"`;
+    }
+
+    // Extract first
+    await this.executeCommand(extractCommand, 120000); // 2 minute timeout
+
+    // Find executable in extracted files
+    const files = await fs.readdir(extractDir);
+    const executable = files.find(file => 
+      file.endsWith('.exe') || file.endsWith('.msi') || file.endsWith('.ps1')
+    );
+
+    if (executable) {
+      const executablePath = path.join(extractDir, executable);
+      return await this.buildInstallCommand(executablePath, force);
+    }
+
+    throw new Error('No executable found in extracted archive');
+  }
+
+  /**
+   * Perform verification for direct installation
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    try {
+      if (!this.verificationCommand) {
+        return {
+          success: false,
+          error: 'No verification command specified',
+          installer: 'direct'
+        };
+      }
+
+      const result = await this.executeCommand(this.verificationCommand, 30000);
+      
+      return {
+        success: result.success,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        installer: 'direct',
+        verified: result.success
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Direct verification failed', {
+          verificationCommand: this.verificationCommand,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get installed version for direct installation
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getInstalledVersion() {
+    try {
+      if (!this.verificationCommand) {
+        return null;
+      }
+
+      const result = await this.executeCommand(this.verificationCommand, 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 direct installation
+   * @returns {Promise<Object>} - Uninstallation result
+   */
+  async uninstall() {
+    try {
+      if (!this.uninstallCommand) {
+        return {
+          success: false,
+          error: 'No uninstall command specified for direct installer',
+          installer: 'direct'
+        };
+      }
+
+      const result = await this.executeCommand(this.uninstallCommand, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('Direct 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: 'direct'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Direct uninstallation failed', {
+          uninstallCommand: this.uninstallCommand,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get direct installer specific information
+   * @returns {Object} - Direct installer info
+   */
+  getInstallerInfo() {
+    return {
+      ...this.getInfo(),
+      installer: 'direct',
+      supportedPlatforms: ['win32', 'darwin', 'linux'],
+      minimumRequirements: ['file system access'],
+      supportedArchitectures: ['x64', 'arm64'],
+      features: [
+        'universal',
+        'no dependencies',
+        'custom scripts',
+        'direct control',
+        'download support'
+      ],
+      limitations: [
+        'manual updates',
+        'verification required',
+        'custom implementation',
+        'error handling varies'
+      ]
+    };
+  }
+}
+
+module.exports = DirectInstaller;