vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/windows/InstallerFactory.js

@@ -0,0 +1,391 @@
+/**
+ * Installation Method Factory
+ * 
+ * Factory for creating appropriate installer instances.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const WinGetInstaller = require('./WinGetInstaller');
+const PowerShellInstaller = require('./PowerShellInstaller');
+const NpmInstaller = require('./NpmInstaller');
+const ChocolateyInstaller = require('./ChocolateyInstaller');
+const DirectInstaller = require('./DirectInstaller');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * Factory class for creating installer instances
+ */
+class InstallerFactory {
+  /**
+   * Create installer instance based on type
+   * @param {string} type - Installation type
+   * @param {Object} config - Installer configuration
+   * @param {Object} logger - Logger instance
+   * @returns {BaseWindowsInstaller} - Installer instance
+   */
+  static createInstaller(type, config = {}, logger = null) {
+    const installerConfig = {
+      ...config,
+      logger
+    };
+
+    switch (type) {
+      case InstallationType.WINGET:
+        return new WinGetInstaller(installerConfig);
+      
+      case InstallationType.POWERSHELL:
+        return new PowerShellInstaller(installerConfig);
+      
+      case InstallationType.NPM:
+        return new NpmInstaller(installerConfig);
+      
+      case InstallationType.CHOCOLATEY:
+        return new ChocolateyInstaller(installerConfig);
+      
+      case InstallationType.DIRECT:
+        return new DirectInstaller(installerConfig);
+      
+      default:
+        throw new Error(`Unknown installation type: ${type}`);
+    }
+  }
+
+  /**
+   * Create all available installers for an agent
+   * @param {Object} agentConfig - Agent configuration
+   * @param {Object} logger - Logger instance
+   * @returns {Array<BaseWindowsInstaller>} - Array of installer instances
+   */
+  static createAllInstallers(agentConfig, logger = null) {
+    const installers = [];
+    
+    if (!agentConfig.installationMethods || !Array.isArray(agentConfig.installationMethods)) {
+      return installers;
+    }
+
+    for (const methodConfig of agentConfig.installationMethods) {
+      try {
+        const installer = this.createInstaller(methodConfig.type, methodConfig, logger);
+        installers.push(installer);
+      } catch (error) {
+        if (logger) {
+          logger.warn(`Failed to create installer for type ${methodConfig.type}`, {
+            error: error.message,
+            agentId: agentConfig.id
+          });
+        }
+      }
+    }
+
+    return installers;
+  }
+
+  /**
+   * Get available installation types
+   * @returns {Array<string>} - Array of installation types
+   */
+  static getAvailableTypes() {
+    return Object.values(InstallationType);
+  }
+
+  /**
+   * Get installation type information
+   * @param {string} type - Installation type
+   * @returns {Object} - Type information
+   */
+  static getTypeInfo(type) {
+    const typeInfo = {
+      [InstallationType.WINGET]: {
+        name: 'WinGet',
+        description: 'Windows Package Manager - Microsoft\'s official package manager',
+        platform: 'win32',
+        priority: 1,
+        features: ['official', 'microsoft-supported', 'automatic-updates'],
+        limitations: ['windows-10-plus-only', 'limited-packages']
+      },
+      [InstallationType.POWERSHELL]: {
+        name: 'PowerShell',
+        description: 'PowerShell script-based installation',
+        platform: 'win32',
+        priority: 2,
+        features: ['flexible', 'custom-scripts', 'remote-support'],
+        limitations: ['script-dependency', 'execution-policy']
+      },
+      [InstallationType.NPM]: {
+        name: 'NPM',
+        description: 'Node Package Manager - for Node.js-based tools',
+        platform: 'all',
+        priority: 2,
+        features: ['cross-platform', 'version-management', 'ecosystem'],
+        limitations: ['nodejs-required', 'internet-required']
+      },
+      [InstallationType.CHOCOLATEY]: {
+        name: 'Chocolatey',
+        description: 'Chocolatey package manager for Windows',
+        platform: 'win32',
+        priority: 3,
+        features: ['large-repo', 'dependency-resolution', 'auto-updates'],
+        limitations: ['windows-only', 'admin-often-required']
+      },
+      [InstallationType.DIRECT]: {
+        name: 'Direct Download',
+        description: 'Direct download and installation',
+        platform: 'all',
+        priority: 4,
+        features: ['universal', 'no-dependencies', 'custom'],
+        limitations: ['manual-updates', 'verification-required']
+      }
+    };
+
+    return typeInfo[type] || {
+      name: 'Unknown',
+      description: 'Unknown installation type',
+      platform: 'unknown',
+      priority: 999,
+      features: [],
+      limitations: []
+    };
+  }
+
+  /**
+   * Get supported installation types for current platform
+   * @returns {Array<string>} - Array of supported types
+   */
+  static getPlatformSupportedTypes() {
+    const platform = process.platform;
+    
+    const platformSupport = {
+      win32: [
+        InstallationType.WINGET,
+        InstallationType.POWERSHELL,
+        InstallationType.NPM,
+        InstallationType.CHOCOLATEY,
+        InstallationType.DIRECT
+      ],
+      darwin: [
+        InstallationType.NPM,
+        InstallationType.DIRECT
+      ],
+      linux: [
+        InstallationType.NPM,
+        InstallationType.DIRECT
+      ]
+    };
+
+    return platformSupport[platform] || [InstallationType.DIRECT];
+  }
+
+  /**
+   * Check if installation type is supported on current platform
+   * @param {string} type - Installation type
+   * @returns {boolean} - True if supported
+   */
+  static isTypeSupported(type) {
+    const supportedTypes = this.getPlatformSupportedTypes();
+    return supportedTypes.includes(type);
+  }
+
+  /**
+   * Get preferred installation types in order of preference
+   * @returns {Array<string>} - Array of types in preference order
+   */
+  static getPreferredOrder() {
+    // Order by priority (lower number = higher preference)
+    const allTypes = this.getAvailableTypes();
+    
+    return allTypes.sort((a, b) => {
+      const infoA = this.getTypeInfo(a);
+      const infoB = this.getTypeInfo(b);
+      
+      return infoA.priority - infoB.priority;
+    });
+  }
+
+  /**
+   * Filter installers by availability
+   * @param {Array<BaseWindowsInstaller>} installers - Array of installers
+   * @returns {Promise<Array<BaseWindowsInstaller>>} - Array of available installers
+   */
+  static async filterByAvailability(installers) {
+    const availableInstallers = [];
+    
+    for (const installer of installers) {
+      try {
+        const isAvailable = await installer.isAvailable();
+        if (isAvailable) {
+          availableInstallers.push(installer);
+        }
+      } catch (error) {
+        // Skip installers that can't be checked for availability
+        continue;
+      }
+    }
+
+    return availableInstallers;
+  }
+
+  /**
+   * Filter installers by requirements
+   * @param {Array<BaseWindowsInstaller>} installers - Array of installers
+   * @returns {Promise<Array<BaseWindowsInstaller>>} - Array of installers that meet requirements
+   */
+  static async filterByRequirements(installers) {
+    const validInstallers = [];
+    
+    for (const installer of installers) {
+      try {
+        const requirements = await installer.checkRequirements();
+        if (requirements.allMet) {
+          validInstallers.push(installer);
+        }
+      } catch (error) {
+        // Skip installers that can't be checked for requirements
+        continue;
+      }
+    }
+
+    return validInstallers;
+  }
+
+  /**
+   * Get best available installer for an agent
+   * @param {Object} agentConfig - Agent configuration
+   * @param {Object} logger - Logger instance
+   * @returns {Promise<BaseWindowsInstaller|null>} - Best installer or null
+   */
+  static async getBestInstaller(agentConfig, logger = null) {
+    const installers = this.createAllInstallers(agentConfig, logger);
+    
+    if (installers.length === 0) {
+      return null;
+    }
+
+    // Filter by platform support
+    const supportedInstallers = installers.filter(installer => 
+      this.isTypeSupported(installer.type)
+    );
+
+    // Filter by availability
+    const availableInstallers = await this.filterByAvailability(supportedInstallers);
+
+    // Filter by requirements
+    const validInstallers = await this.filterByRequirements(availableInstallers);
+
+    if (validInstallers.length === 0) {
+      return null;
+    }
+
+    // Sort by preference and return the best one
+    validInstallers.sort((a, b) => {
+      const infoA = this.getTypeInfo(a.type);
+      const infoB = this.getTypeInfo(b.type);
+      
+      return infoA.priority - infoB.priority;
+    });
+
+    return validInstallers[0];
+  }
+
+  /**
+   * Get all available installers for an agent with their status
+   * @param {Object} agentConfig - Agent configuration
+   * @param {Object} logger - Logger instance
+   * @returns {Promise<Array<Object>>} - Array of installer status objects
+   */
+  static async getInstallerStatuses(agentConfig, logger = null) {
+    const installers = this.createAllInstallers(agentConfig, logger);
+    const statuses = [];
+
+    for (const installer of installers) {
+      try {
+        const isSupported = this.isTypeSupported(installer.type);
+        const isAvailable = isSupported ? await installer.isAvailable() : false;
+        const requirements = isAvailable ? await installer.checkRequirements() : null;
+        const meetsRequirements = requirements ? requirements.allMet : false;
+
+        statuses.push({
+          type: installer.type,
+          name: this.getTypeInfo(installer.type).name,
+          supported: isSupported,
+          available: isAvailable,
+          meetsRequirements,
+          requirements,
+          priority: this.getTypeInfo(installer.type).priority,
+          installer: isAvailable && meetsRequirements ? installer : null
+        });
+      } catch (error) {
+        statuses.push({
+          type: installer.type,
+          name: this.getTypeInfo(installer.type).name,
+          supported: false,
+          available: false,
+          meetsRequirements: false,
+          requirements: null,
+          priority: this.getTypeInfo(installer.type).priority,
+          error: error.message,
+          installer: null
+        });
+      }
+    }
+
+    // Sort by priority
+    statuses.sort((a, b) => a.priority - b.priority);
+
+    return statuses;
+  }
+
+  /**
+   * Validate installation method configuration
+   * @param {Object} methodConfig - Installation method configuration
+   * @returns {Object} - Validation result
+   */
+  static validateMethodConfig(methodConfig) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    if (!methodConfig.type) {
+      result.valid = false;
+      result.errors.push('Installation method must have a type');
+    }
+
+    if (!Object.values(InstallationType).includes(methodConfig.type)) {
+      result.valid = false;
+      result.errors.push(`Invalid installation type: ${methodConfig.type}`);
+    }
+
+    if (!methodConfig.command && methodConfig.type !== InstallationType.WINGET && methodConfig.type !== InstallationType.CHOCOLATEY) {
+      result.valid = false;
+      result.errors.push('Installation method must have a command');
+    }
+
+    if ((methodConfig.type === InstallationType.WINGET || methodConfig.type === InstallationType.CHOCOLATEY) && !methodConfig.packageId) {
+      result.valid = false;
+      result.errors.push(`Package ID is required for ${methodConfig.type} installation type`);
+    }
+
+    if (!methodConfig.verificationCommand) {
+      result.warnings.push('Installation method should have a verification command');
+    }
+
+    return result;
+  }
+
+  /**
+   * Get factory statistics
+   * @returns {Object} - Factory information
+   */
+  static getFactoryInfo() {
+    return {
+      supportedTypes: this.getAvailableTypes(),
+      platformSupportedTypes: this.getPlatformSupportedTypes(),
+      preferredOrder: this.getPreferredOrder(),
+      currentPlatform: process.platform,
+      totalTypes: Object.values(InstallationType).length
+    };
+  }
+}
+
+module.exports = InstallerFactory;