vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/EnvironmentConfigurationManager.js

@@ -0,0 +1,602 @@
+/**
+ * Environment Configuration Manager
+ * 
+ * Manages environment variable support for agent configuration.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * Environment Configuration Manager class
+ */
+class EnvironmentConfigurationManager {
+  /**
+   * Create environment configuration manager instance
+   * @param {Object} options - Manager options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.prefix = options.prefix || 'VIBECODINGMACHINE_';
+    this.configFile = options.configFile || null;
+    this.overrideFile = options.overrideFile || path.join(os.homedir(), '.vibecodingmachine', 'env.json');
+    this.caseSensitive = options.caseSensitive !== false; // Default to case sensitive
+    
+    // Environment variable mappings
+    this.variableMappings = {
+      // Installation settings
+      'INSTALL_TIMEOUT': 'installation.timeout',
+      'MAX_CONCURRENT_INSTALLATIONS': 'installation.maxConcurrent',
+      'RETRY_ATTEMPTS': 'installation.retryAttempts',
+      'RETRY_DELAY': 'installation.retryDelay',
+      'AUTO_ELEVATE': 'installation.autoElevate',
+      
+      // Logging settings
+      'LOG_LEVEL': 'logging.level',
+      'LOG_FILE': 'logging.file',
+      'LOG_FORMAT': 'logging.format',
+      'VERBOSE_LOGGING': 'logging.verbose',
+      
+      // Cache settings
+      'CACHE_DIR': 'cache.directory',
+      'CACHE_SIZE': 'cache.maxSize',
+      'CACHE_TTL': 'cache.ttl',
+      
+      // Network settings
+      'HTTP_TIMEOUT': 'network.timeout',
+      'HTTP_PROXY': 'network.proxy',
+      'HTTP_USER_AGENT': 'network.userAgent',
+      'RATE_LIMIT_DELAY': 'network.rateLimitDelay',
+      
+      // Security settings
+      'SECURITY_STRICT_MODE': 'security.strictMode',
+      'SECURITY_MAX_FILE_SIZE': 'security.maxFileSize',
+      'SECURITY_ALLOWED_EXTENSIONS': 'security.allowedExtensions',
+      
+      // Performance settings
+      'PERFORMANCE_MONITORING': 'performance.monitoring',
+      'PERFORMANCE_METRICS_FILE': 'performance.metricsFile',
+      'PERFORMANCE_FLUSH_INTERVAL': 'performance.flushInterval',
+      
+      // Agent settings
+      'DEFAULT_AGENTS_FILE': 'agents.defaultFile',
+      'AGENT_DISCOVERY_ENABLED': 'agents.discoveryEnabled',
+      'AGENT_AUTO_UPDATE': 'agents.autoUpdate'
+    };
+    
+    // Type conversion functions
+    this.typeConverters = {
+      'boolean': (value) => {
+        if (typeof value === 'boolean') return value;
+        const str = String(value).toLowerCase();
+        return str === 'true' || str === '1' || str === 'yes' || str === 'on';
+      },
+      'number': (value) => {
+        const num = Number(value);
+        return isNaN(num) ? 0 : num;
+      },
+      'string': (value) => String(value),
+      'array': (value) => {
+        if (Array.isArray(value)) return value;
+        const str = String(value);
+        try {
+          return JSON.parse(str);
+        } catch {
+          return str.split(',').map(s => s.trim()).filter(s => s);
+        }
+      },
+      'object': (value) => {
+        if (typeof value === 'object' && value !== null) return value;
+        const str = String(value);
+        try {
+          return JSON.parse(str);
+        } catch {
+          return {};
+        }
+      }
+    };
+    
+    // Default configuration schema
+    this.defaultConfig = {
+      installation: {
+        timeout: 300000,
+        maxConcurrent: 2,
+        retryAttempts: 3,
+        retryDelay: 5000,
+        autoElevate: false
+      },
+      logging: {
+        level: 'info',
+        file: null,
+        format: 'json',
+        verbose: false
+      },
+      cache: {
+        directory: './cache',
+        maxSize: 100 * 1024 * 1024, // 100MB
+        ttl: 3600000 // 1 hour
+      },
+      network: {
+        timeout: 30000,
+        proxy: null,
+        userAgent: null,
+        rateLimitDelay: 1000
+      },
+      security: {
+        strictMode: true,
+        maxFileSize: 100 * 1024 * 1024, // 100MB
+        allowedExtensions: ['.exe', '.msi', '.zip', '.tar', '.gz']
+      },
+      performance: {
+        monitoring: true,
+        metricsFile: null,
+        flushInterval: 60000
+      },
+      agents: {
+        defaultFile: './config/agents.json',
+        discoveryEnabled: true,
+        autoUpdate: false
+      }
+    };
+  }
+
+  /**
+   * Load configuration from environment variables and files
+   * @returns {Promise<Object>} - Loaded configuration
+   */
+  async loadConfiguration() {
+    const config = JSON.parse(JSON.stringify(this.defaultConfig)); // Deep clone
+    
+    try {
+      // Load from override file first
+      const overrideConfig = await this.loadOverrideFile();
+      this.mergeConfig(config, overrideConfig);
+      
+      // Load from environment variables
+      const envConfig = this.loadEnvironmentVariables();
+      this.mergeConfig(config, envConfig);
+      
+      // Load from specified config file
+      if (this.configFile) {
+        const fileConfig = await this.loadConfigFile(this.configFile);
+        this.mergeConfig(config, fileConfig);
+      }
+      
+      if (this.logger) {
+        this.logger.info('Configuration loaded successfully', {
+          sources: ['override file', 'environment variables', 'config file'].filter(Boolean),
+          configKeys: Object.keys(config)
+        });
+      }
+      
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error('Failed to load configuration', { error: error.message });
+      }
+      
+      // Return default configuration on error
+      return JSON.parse(JSON.stringify(this.defaultConfig));
+    }
+    
+    return config;
+  }
+
+  /**
+   * Load configuration from override file
+   * @returns {Promise<Object>} - Override configuration
+   */
+  async loadOverrideFile() {
+    try {
+      const exists = await fs.access(this.overrideFile).then(() => true).catch(() => false);
+      if (!exists) return {};
+      
+      const content = await fs.readFile(this.overrideFile, 'utf8');
+      const config = JSON.parse(content);
+      
+      if (this.logger) {
+        this.logger.debug('Loaded override file configuration', { 
+          file: this.overrideFile,
+          keys: Object.keys(config)
+        });
+      }
+      
+      return config;
+    } catch (error) {
+      if (this.logger) {
+        this.logger.warn('Failed to load override file', { 
+          file: this.overrideFile,
+          error: error.message 
+        });
+      }
+      return {};
+    }
+  }
+
+  /**
+   * Load configuration from environment variables
+   * @returns {Object} - Environment configuration
+   */
+  loadEnvironmentVariables() {
+    const config = {};
+    
+    for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
+      const fullEnvVar = this.prefix + envVar;
+      const value = process.env[fullEnvVar];
+      
+      if (value !== undefined) {
+        this.setNestedValue(config, configPath, value);
+        
+        if (this.logger) {
+          this.logger.debug('Loaded environment variable', {
+            variable: fullEnvVar,
+            configPath,
+            value
+          });
+        }
+      }
+    }
+    
+    return config;
+  }
+
+  /**
+   * Load configuration from file
+   * @param {string} filePath - Path to config file
+   * @returns {Promise<Object>} - File configuration
+   */
+  async loadConfigFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const config = JSON.parse(content);
+      
+      if (this.logger) {
+        this.logger.debug('Loaded config file', { 
+          file: filePath,
+          keys: Object.keys(config)
+        });
+      }
+      
+      return config;
+    } catch (error) {
+      if (this.logger) {
+        this.logger.warn('Failed to load config file', { 
+          file: filePath,
+          error: error.message 
+        });
+      }
+      return {};
+    }
+  }
+
+  /**
+   * Save configuration to override file
+   * @param {Object} config - Configuration to save
+   * @returns {Promise<Object>} - Save result
+   */
+  async saveConfiguration(config) {
+    const result = {
+      success: false,
+      error: null,
+      filePath: this.overrideFile
+    };
+    
+    try {
+      // Ensure directory exists
+      const dir = path.dirname(this.overrideFile);
+      await fs.mkdir(dir, { recursive: true });
+      
+      // Save configuration
+      const content = JSON.stringify(config, null, 2);
+      await fs.writeFile(this.overrideFile, content, 'utf8');
+      
+      result.success = true;
+      
+      if (this.logger) {
+        this.logger.info('Configuration saved successfully', { 
+          file: this.overrideFile,
+          keys: Object.keys(config)
+        });
+      }
+      
+    } catch (error) {
+      result.error = error.message;
+      
+      if (this.logger) {
+        this.logger.error('Failed to save configuration', { 
+          file: this.overrideFile,
+          error: error.message 
+        });
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Set configuration value
+   * @param {string} key - Configuration key
+   * @param {*} value - Configuration value
+   * @param {string} type - Value type
+   * @returns {Promise<Object>} - Set result
+   */
+  async setConfigurationValue(key, value, type = 'string') {
+    const result = {
+      success: false,
+      error: null,
+      previousValue: null
+    };
+    
+    try {
+      // Load current configuration
+      const config = await this.loadConfiguration();
+      result.previousValue = this.getNestedValue(config, key);
+      
+      // Convert value type
+      const convertedValue = this.typeConverters[type] ? 
+        this.typeConverters[type](value) : value;
+      
+      // Set new value
+      this.setNestedValue(config, key, convertedValue);
+      
+      // Save configuration
+      const saveResult = await this.saveConfiguration(config);
+      result.success = saveResult.success;
+      result.error = saveResult.error;
+      
+      if (this.logger) {
+        this.logger.info('Configuration value set', {
+          key,
+          value: convertedValue,
+          type,
+          previousValue: result.previousValue
+        });
+      }
+      
+    } catch (error) {
+      result.error = error.message;
+      
+      if (this.logger) {
+        this.logger.error('Failed to set configuration value', {
+          key,
+          value,
+          error: error.message
+        });
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get configuration value
+   * @param {string} key - Configuration key
+   * @param {*} defaultValue - Default value
+   * @returns {Promise<*>} - Configuration value
+   */
+  async getConfigurationValue(key, defaultValue = null) {
+    try {
+      const config = await this.loadConfiguration();
+      const value = this.getNestedValue(config, key);
+      return value !== undefined ? value : defaultValue;
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error('Failed to get configuration value', {
+          key,
+          error: error.message
+        });
+      }
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Set nested configuration value
+   * @param {Object} obj - Target object
+   * @param {string} path - Dot-separated path
+   * @param {*} value - Value to set
+   */
+  setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!(key in current) || typeof current[key] !== 'object') {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    
+    current[keys[keys.length - 1]] = value;
+  }
+
+  /**
+   * Get nested configuration value
+   * @param {Object} obj - Source object
+   * @param {string} path - Dot-separated path
+   * @returns {*} - Configuration value
+   */
+  getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    
+    for (const key of keys) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        return undefined;
+      }
+    }
+    
+    return current;
+  }
+
+  /**
+   * Merge configuration objects
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object
+   */
+  mergeConfig(target, source) {
+    this.deepMerge(target, source);
+  }
+
+  /**
+   * Deep merge objects
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object
+   */
+  deepMerge(target, source) {
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        if (!target[key] || typeof target[key] !== 'object') {
+          target[key] = {};
+        }
+        this.deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  /**
+   * Get environment variable documentation
+   * @returns {Object} - Environment variable documentation
+   */
+  getEnvironmentVariableDocumentation() {
+    const docs = {};
+    
+    for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
+      const fullEnvVar = this.prefix + envVar;
+      const defaultValue = this.getNestedValue(this.defaultConfig, configPath);
+      
+      docs[fullEnvVar] = {
+        configPath,
+        description: this.getVariableDescription(envVar),
+        defaultValue,
+        type: this.getVariableType(configPath, defaultValue)
+      };
+    }
+    
+    return docs;
+  }
+
+  /**
+   * Get variable description
+   * @param {string} envVar - Environment variable name
+   * @returns {string} - Description
+   */
+  getVariableDescription(envVar) {
+    const descriptions = {
+      'INSTALL_TIMEOUT': 'Installation timeout in milliseconds',
+      'MAX_CONCURRENT_INSTALLATIONS': 'Maximum concurrent installations',
+      'RETRY_ATTEMPTS': 'Number of retry attempts for failed operations',
+      'RETRY_DELAY': 'Delay between retry attempts in milliseconds',
+      'AUTO_ELEVATE': 'Automatically request administrator privileges',
+      'LOG_LEVEL': 'Logging level (error, warn, info, debug)',
+      'LOG_FILE': 'Path to log file',
+      'LOG_FORMAT': 'Log format (json, text)',
+      'VERBOSE_LOGGING': 'Enable verbose logging',
+      'CACHE_DIR': 'Cache directory path',
+      'CACHE_SIZE': 'Maximum cache size in bytes',
+      'CACHE_TTL': 'Cache time-to-live in milliseconds',
+      'HTTP_TIMEOUT': 'HTTP request timeout in milliseconds',
+      'HTTP_PROXY': 'HTTP proxy URL',
+      'HTTP_USER_AGENT': 'HTTP user agent string',
+      'RATE_LIMIT_DELAY': 'Delay for rate limiting in milliseconds',
+      'SECURITY_STRICT_MODE': 'Enable strict security mode',
+      'SECURITY_MAX_FILE_SIZE': 'Maximum allowed file size in bytes',
+      'SECURITY_ALLOWED_EXTENSIONS': 'Comma-separated list of allowed file extensions',
+      'PERFORMANCE_MONITORING': 'Enable performance monitoring',
+      'PERFORMANCE_METRICS_FILE': 'Path to performance metrics file',
+      'PERFORMANCE_FLUSH_INTERVAL': 'Performance metrics flush interval in milliseconds',
+      'DEFAULT_AGENTS_FILE': 'Path to default agents configuration file',
+      'AGENT_DISCOVERY_ENABLED': 'Enable automatic agent discovery',
+      'AGENT_AUTO_UPDATE': 'Enable automatic agent updates'
+    };
+    
+    return descriptions[envVar] || 'Configuration variable';
+  }
+
+  /**
+   * Get variable type
+   * @param {string} configPath - Configuration path
+   * @param {*} defaultValue - Default value
+   * @returns {string} - Variable type
+   */
+  getVariableType(configPath, defaultValue) {
+    if (typeof defaultValue === 'boolean') return 'boolean';
+    if (typeof defaultValue === 'number') return 'number';
+    if (Array.isArray(defaultValue)) return 'array';
+    if (typeof defaultValue === 'object' && defaultValue !== null) return 'object';
+    return 'string';
+  }
+
+  /**
+   * Export configuration to environment file
+   * @param {string} filePath - Export file path
+   * @returns {Promise<Object>} - Export result
+   */
+  async exportToEnvironmentFile(filePath) {
+    const result = {
+      success: false,
+      error: null,
+      filePath
+    };
+    
+    try {
+      const config = await this.loadConfiguration();
+      const envVars = [];
+      
+      for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
+        const value = this.getNestedValue(config, configPath);
+        if (value !== undefined && value !== this.getNestedValue(this.defaultConfig, configPath)) {
+          const fullEnvVar = this.prefix + envVar;
+          envVars.push(`${fullEnvVar}=${JSON.stringify(value)}`);
+        }
+      }
+      
+      const content = envVars.join('\n');
+      await fs.writeFile(filePath, content, 'utf8');
+      
+      result.success = true;
+      
+      if (this.logger) {
+        this.logger.info('Configuration exported to environment file', {
+          filePath,
+          variableCount: envVars.length
+        });
+      }
+      
+    } catch (error) {
+      result.error = error.message;
+      
+      if (this.logger) {
+        this.logger.error('Failed to export configuration', {
+          filePath,
+          error: error.message
+        });
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get current configuration
+   * @returns {Object} - Current configuration
+   */
+  getCurrentConfiguration() {
+    return {
+      prefix: this.prefix,
+      configFile: this.configFile,
+      overrideFile: this.overrideFile,
+      caseSensitive: this.caseSensitive,
+      variableCount: Object.keys(this.variableMappings).length,
+      supportedVariables: Object.keys(this.variableMappings).map(v => this.prefix + v)
+    };
+  }
+}
+
+module.exports = EnvironmentConfigurationManager;