vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/windows/NpmInstaller.js

@@ -0,0 +1,505 @@
+/**
+ * NPM Installer
+ * 
+ * Node Package Manager (npm) installer implementation.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const BaseWindowsInstaller = require('./BaseWindowsInstaller');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * NPM installer class for Windows agents
+ */
+class NpmInstaller extends BaseWindowsInstaller {
+  /**
+   * Create NPM installer instance
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.NPM,
+      ...config
+    });
+    
+    this.global = config.global !== false; // Default to global installation
+    this.registry = config.registry || '';
+    this.scope = config.scope || '';
+  }
+
+  /**
+   * Check if npm is available on current system
+   * @returns {Promise<boolean>} - True if npm is available
+   */
+  async isAvailable() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('npm --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('npm not available', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check system requirements for npm
+   * @returns {Promise<Object>} - Requirements check result
+   */
+  async checkRequirements() {
+    const requirements = await super.checkRequirements();
+    
+    // npm-specific requirements
+    const npmRequirements = [
+      { requirement: 'node.js', met: await this.checkNodeJS() },
+      { requirement: 'npm', met: await this.isAvailable() },
+      { requirement: 'internet', met: await this.checkInternetConnection() }
+    ];
+
+    npmRequirements.forEach(req => {
+      requirements.requirements.push(req);
+      if (!req.met) {
+        requirements.allMet = false;
+      }
+    });
+
+    return requirements;
+  }
+
+  /**
+   * Check if Node.js is available
+   * @returns {Promise<boolean>} - True if Node.js is available
+   */
+  async checkNodeJS() {
+    try {
+      const { execSync } = require('child_process');
+      execSync('node --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.debug('Node.js 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 registry.npmjs.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 npm
+   * @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 npm', {
+        packageId: this.packageId,
+        command,
+        global: this.global,
+        force
+      });
+    }
+
+    try {
+      const result = await this.executeCommand(command, timeout);
+      
+      if (this.logger) {
+        await this.logger.info('npm 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: 'npm'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('npm installation failed', {
+          packageId: this.packageId,
+          error: error.message,
+          command
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Build npm install command
+   * @param {boolean} force - Force reinstall
+   * @returns {string} - npm command
+   */
+  buildInstallCommand(force) {
+    let command = 'npm install';
+    
+    // Add global flag if specified
+    if (this.global) {
+      command += ' --global';
+    }
+    
+    // Add package name or path
+    if (this.packageId) {
+      command += ` ${this.packageId}`;
+    } else if (this.command) {
+      command += ` ${this.command}`;
+    }
+    
+    // Add force flag if requested
+    if (force) {
+      command += ' --force';
+    }
+    
+    // Add registry if specified
+    if (this.registry) {
+      command += ` --registry ${this.registry}`;
+    }
+    
+    // Add scope if specified
+    if (this.scope) {
+      command += ` --scope ${this.scope}`;
+    }
+    
+    // Add other useful flags
+    command += ' --no-audit --no-fund';
+    
+    return command;
+  }
+
+  /**
+   * Perform verification using npm
+   * @returns {Promise<Object>} - Verification result
+   */
+  async performVerification() {
+    try {
+      // First check if package is installed using npm list
+      const listCommand = this.global ? 
+        `npm list --global --depth=0 ${this.packageId}` :
+        `npm list --depth=0 ${this.packageId}`;
+      
+      const listResult = await this.executeCommand(listCommand, 30000);
+      
+      if (!listResult.success) {
+        return {
+          success: false,
+          error: 'Package not found in npm list',
+          exitCode: listResult.exitCode,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'npm'
+        };
+      }
+
+      // Check if package is actually installed
+      const isInstalled = listResult.stdout.includes(this.packageId) || 
+                        listResult.stdout.includes('empty') === false;
+
+      if (!isInstalled) {
+        return {
+          success: false,
+          error: 'Package not properly installed',
+          exitCode: 1,
+          stdout: listResult.stdout,
+          stderr: listResult.stderr,
+          installer: 'npm'
+        };
+      }
+
+      // 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: 'npm',
+          verified: verifyResult.success
+        };
+      }
+
+      return {
+        success: true,
+        exitCode: 0,
+        stdout: listResult.stdout,
+        stderr: '',
+        installer: 'npm',
+        verified: true
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('npm verification failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get installed version using npm
+   * @returns {Promise<string|null>} - Version string or null
+   */
+  async getInstalledVersion() {
+    try {
+      const command = this.global ? 
+        `npm list --global --depth=0 --json ${this.packageId}` :
+        `npm list --depth=0 --json ${this.packageId}`;
+      
+      const result = await this.executeCommand(command, 30000);
+      
+      if (result.success) {
+        try {
+          const packageInfo = JSON.parse(result.stdout);
+          
+          // Navigate npm list JSON structure
+          let version = null;
+          if (packageInfo.dependencies && packageInfo.dependencies[this.packageId]) {
+            version = packageInfo.dependencies[this.packageId].version;
+          } else if (packageInfo[this.packageId]) {
+            version = packageInfo[this.packageId].version;
+          }
+          
+          return version;
+        } catch (parseError) {
+          // Fallback to text parsing
+          const lines = result.stdout.split('\n');
+          const versionLine = lines.find(line => 
+            line.includes(this.packageId) && 
+            line.includes('@')
+          );
+          
+          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', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Uninstall package using npm
+   * @returns {Promise<Object>} - Uninstallation result
+   */
+  async uninstall() {
+    try {
+      let command = 'npm uninstall';
+      
+      if (this.global) {
+        command += ' --global';
+      }
+      
+      command += ` ${this.packageId}`;
+      
+      if (this.logger) {
+        await this.logger.info('Uninstalling with npm', {
+          packageId: this.packageId,
+          command,
+          global: this.global
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('npm 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: 'npm'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('npm uninstallation failed', {
+          packageId: this.packageId,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Update package using npm
+   * @returns {Promise<Object>} - Update result
+   */
+  async update() {
+    try {
+      let command = 'npm update';
+      
+      if (this.global) {
+        command += ' --global';
+      }
+      
+      command += ` ${this.packageId}`;
+      command += ' --no-audit --no-fund';
+      
+      if (this.logger) {
+        await this.logger.info('Updating with npm', {
+          packageId: this.packageId,
+          command,
+          global: this.global
+        });
+      }
+
+      const result = await this.executeCommand(command, 300000); // 5 minute timeout
+      
+      if (this.logger) {
+        await this.logger.info('npm 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: 'npm'
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('npm 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 = this.global ? 
+        `npm outdated --global --json ${this.packageId}` :
+        `npm outdated --json ${this.packageId}`;
+      
+      const result = await this.executeCommand(command, 60000); // 1 minute timeout
+      
+      if (result.success && result.stdout.trim()) {
+        try {
+          const outdatedInfo = JSON.parse(result.stdout);
+          const packageInfo = outdatedInfo[this.packageId];
+          
+          if (packageInfo) {
+            return {
+              updateAvailable: true,
+              current: packageInfo.current,
+              wanted: packageInfo.wanted,
+              latest: packageInfo.latest,
+              installer: 'npm'
+            };
+          }
+        } catch (parseError) {
+          // Ignore JSON parsing errors
+        }
+      }
+      
+      return {
+        updateAvailable: false,
+        current: await this.getInstalledVersion(),
+        installer: 'npm'
+      };
+    } 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: 'npm'
+      };
+    }
+  }
+
+  /**
+   * Get npm-specific information
+   * @returns {Object} - npm installer info
+   */
+  getInstallerInfo() {
+    return {
+      ...this.getInfo(),
+      installer: 'npm',
+      supportedPlatforms: ['win32', 'darwin', 'linux'],
+      minimumNodeVersion: '14.0.0',
+      supportedArchitectures: ['x64', 'arm64'],
+      features: [
+        'global installation',
+        'version management',
+        'dependency resolution',
+        'registry support',
+        'update checking'
+      ],
+      limitations: [
+        'requires Node.js',
+        'internet connection required',
+        'registry dependencies',
+        'package availability varies'
+      ]
+    };
+  }
+}
+
+module.exports = NpmInstaller;