claude-flow-novice 1.0.0

package/dist/src/core/config.js

@@ -0,0 +1,1221 @@
+/**
+ * Enterprise Configuration Management for Claude-Flow
+ * Features: Security masking, change tracking, multi-format support, credential management
+ */ import { promises as fs } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import { safeParseJSON } from '../utils/helpers.js';
+import { ConfigError, ValidationError } from '../utils/errors.js';
+/**
+ * Security classifications for configuration paths
+ */ const SECURITY_CLASSIFICATIONS = {
+    credentials: {
+        level: 'secret',
+        encrypted: true
+    },
+    'credentials.apiKey': {
+        level: 'secret',
+        maskPattern: '****...****',
+        encrypted: true
+    },
+    'credentials.token': {
+        level: 'secret',
+        maskPattern: '****...****',
+        encrypted: true
+    },
+    'credentials.password': {
+        level: 'secret',
+        maskPattern: '********',
+        encrypted: true
+    },
+    'mcp.apiKey': {
+        level: 'confidential',
+        maskPattern: '****...****'
+    },
+    'logging.destination': {
+        level: 'internal'
+    },
+    orchestrator: {
+        level: 'internal'
+    },
+    terminal: {
+        level: 'public'
+    }
+};
+/**
+ * Sensitive configuration paths that should be masked in output
+ */ const SENSITIVE_PATHS = [
+    'credentials',
+    'apiKey',
+    'token',
+    'password',
+    'secret',
+    'key',
+    'auth'
+];
+/**
+ * Format parsers for different configuration file types
+ */ const FORMAT_PARSERS = {
+    json: {
+        parse: JSON.parse,
+        stringify: (obj)=>JSON.stringify(obj, null, 2),
+        extension: '.json'
+    },
+    yaml: {
+        parse: (content)=>{
+            // Simple YAML parser for basic key-value pairs
+            const lines = content.split('\n');
+            const result = {};
+            let current = result;
+            const stack = [
+                result
+            ];
+            for (const line of lines){
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) continue;
+                const indent = line.length - line.trimStart().length;
+                const colonIndex = trimmed.indexOf(':');
+                if (colonIndex === -1) continue;
+                const key = trimmed.substring(0, colonIndex).trim();
+                const value = trimmed.substring(colonIndex + 1).trim();
+                // Simple value parsing
+                let parsedValue = value;
+                if (value === 'true') parsedValue = true;
+                else if (value === 'false') parsedValue = false;
+                else if (!isNaN(Number(value)) && value !== '') parsedValue = Number(value);
+                else if (value.startsWith('"') && value.endsWith('"')) {
+                    parsedValue = value.slice(1, -1);
+                }
+                current[key] = parsedValue;
+            }
+            return result;
+        },
+        stringify: (obj)=>{
+            const stringify = (obj, indent = 0)=>{
+                const spaces = '  '.repeat(indent);
+                let result = '';
+                for (const [key, value] of Object.entries(obj)){
+                    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                        result += `${spaces}${key}:\n${stringify(value, indent + 1)}`;
+                    } else {
+                        const formattedValue = typeof value === 'string' ? `"${value}"` : String(value);
+                        result += `${spaces}${key}: ${formattedValue}\n`;
+                    }
+                }
+                return result;
+            };
+            return stringify(obj);
+        },
+        extension: '.yaml'
+    },
+    toml: {
+        parse: (content)=>{
+            // Simple TOML parser for basic sections and key-value pairs
+            const lines = content.split('\n');
+            const result = {};
+            let currentSection = result;
+            for (const line of lines){
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) continue;
+                // Section header
+                if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                    const sectionName = trimmed.slice(1, -1);
+                    currentSection = result[sectionName] = {};
+                    continue;
+                }
+                // Key-value pair
+                const equalsIndex = trimmed.indexOf('=');
+                if (equalsIndex === -1) continue;
+                const key = trimmed.substring(0, equalsIndex).trim();
+                const value = trimmed.substring(equalsIndex + 1).trim();
+                // Simple value parsing
+                let parsedValue = value;
+                if (value === 'true') parsedValue = true;
+                else if (value === 'false') parsedValue = false;
+                else if (!isNaN(Number(value)) && value !== '') parsedValue = Number(value);
+                else if (value.startsWith('"') && value.endsWith('"')) {
+                    parsedValue = value.slice(1, -1);
+                }
+                currentSection[key] = parsedValue;
+            }
+            return result;
+        },
+        stringify: (obj)=>{
+            let result = '';
+            for (const [section, values] of Object.entries(obj)){
+                if (typeof values === 'object' && values !== null && !Array.isArray(values)) {
+                    result += `[${section}]\n`;
+                    for (const [key, value] of Object.entries(values)){
+                        const formattedValue = typeof value === 'string' ? `"${value}"` : String(value);
+                        result += `${key} = ${formattedValue}\n`;
+                    }
+                    result += '\n';
+                }
+            }
+            return result;
+        },
+        extension: '.toml'
+    }
+};
+/**
+ * Default configuration values
+ */ const DEFAULT_CONFIG = {
+    orchestrator: {
+        maxConcurrentAgents: 10,
+        taskQueueSize: 100,
+        healthCheckInterval: 30000,
+        shutdownTimeout: 30000
+    },
+    terminal: {
+        type: 'auto',
+        poolSize: 5,
+        recycleAfter: 10,
+        healthCheckInterval: 60000,
+        commandTimeout: 300000
+    },
+    memory: {
+        backend: 'hybrid',
+        cacheSizeMB: 100,
+        syncInterval: 5000,
+        conflictResolution: 'crdt',
+        retentionDays: 30
+    },
+    coordination: {
+        maxRetries: 3,
+        retryDelay: 1000,
+        deadlockDetection: true,
+        resourceTimeout: 60000,
+        messageTimeout: 30000
+    },
+    mcp: {
+        transport: 'stdio',
+        port: 3000,
+        tlsEnabled: false
+    },
+    logging: {
+        level: 'info',
+        format: 'json',
+        destination: 'console'
+    },
+    credentials: {
+    },
+    security: {
+        encryptionEnabled: true,
+        auditLogging: true,
+        maskSensitiveValues: true,
+        allowEnvironmentOverrides: true
+    }
+};
+/**
+ * Configuration manager
+ */ export class ConfigManager {
+    static instance;
+    config;
+    configPath;
+    profiles = new Map();
+    currentProfile;
+    userConfigDir;
+    changeHistory = [];
+    encryptionKey;
+    validationRules = new Map();
+    formatParsers = FORMAT_PARSERS;
+    constructor(){
+        this.config = deepClone(DEFAULT_CONFIG);
+        this.userConfigDir = this.getUserConfigDir();
+        this.setupValidationRules();
+    // Encryption will be initialized via init() method
+    }
+    /**
+   * Gets the singleton instance
+   */ static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+   * Initialize async components
+   */ async init() {
+        await this.initializeEncryption();
+    }
+    /**
+   * Initializes encryption for sensitive configuration values
+   */ async initializeEncryption() {
+        try {
+            const keyFile = join(this.userConfigDir, '.encryption-key');
+            // Check if key file exists (simplified for demo)
+            try {
+                await fs.access(keyFile);
+                // In a real implementation, this would be more secure
+                this.encryptionKey = randomBytes(32);
+            } catch  {
+                this.encryptionKey = randomBytes(32);
+            // Store key securely (in production, use proper key management)
+            }
+        } catch (error) {
+            console.warn('Failed to initialize encryption:', error.message);
+        }
+    }
+    /**
+   * Sets up validation rules for configuration paths
+   */ setupValidationRules() {
+        // Orchestrator validation rules
+        this.validationRules.set('orchestrator.maxConcurrentAgents', {
+            type: 'number',
+            required: true,
+            min: 1,
+            max: 100,
+            validator: (value, config)=>{
+                if (value > config.terminal?.poolSize * 2) {
+                    return 'maxConcurrentAgents should not exceed 2x terminal pool size';
+                }
+                return null;
+            }
+        });
+        this.validationRules.set('orchestrator.taskQueueSize', {
+            type: 'number',
+            required: true,
+            min: 1,
+            max: 10000,
+            dependencies: [
+                'orchestrator.maxConcurrentAgents'
+            ],
+            validator: (value, config)=>{
+                const maxAgents = config.orchestrator?.maxConcurrentAgents || 1;
+                if (value < maxAgents * 10) {
+                    return 'taskQueueSize should be at least 10x maxConcurrentAgents';
+                }
+                return null;
+            }
+        });
+        // Terminal validation rules
+        this.validationRules.set('terminal.type', {
+            type: 'string',
+            required: true,
+            values: [
+                'auto',
+                'vscode',
+                'native'
+            ]
+        });
+        this.validationRules.set('terminal.poolSize', {
+            type: 'number',
+            required: true,
+            min: 1,
+            max: 50
+        });
+        // Memory validation rules
+        this.validationRules.set('memory.backend', {
+            type: 'string',
+            required: true,
+            values: [
+                'sqlite',
+                'markdown',
+                'hybrid'
+            ]
+        });
+        this.validationRules.set('memory.cacheSizeMB', {
+            type: 'number',
+            required: true,
+            min: 1,
+            max: 10000,
+            validator: (value)=>{
+                if (value > 1000) {
+                    return 'Large cache sizes may impact system performance';
+                }
+                return null;
+            }
+        });
+        // Security validation rules
+        this.validationRules.set('security.encryptionEnabled', {
+            type: 'boolean',
+            required: true
+        });
+        // Credentials validation
+        this.validationRules.set('credentials.apiKey', {
+            type: 'string',
+            pattern: /^[a-zA-Z0-9_-]+$/,
+            validator: (value)=>{
+                if (value && value.length < 16) {
+                    return 'API key should be at least 16 characters long';
+                }
+                return null;
+            }
+        });
+    }
+    /**
+   * Loads configuration from various sources
+   */ async load(configPath) {
+        if (configPath !== undefined) {
+            this.configPath = configPath;
+        }
+        // Start with defaults
+        let config = deepClone(DEFAULT_CONFIG);
+        // Load from file if specified
+        if (configPath) {
+            const fileConfig = await this.loadFromFile(configPath);
+            config = deepMergeConfig(config, fileConfig);
+        }
+        // Load from environment variables
+        const envConfig = this.loadFromEnv();
+        config = deepMergeConfig(config, envConfig);
+        // Validate the final configuration
+        this.validate(config);
+        this.config = config;
+        return config;
+    }
+    /**
+   * Gets the current configuration with optional security masking
+   */ get(maskSensitive = false) {
+        const config = deepClone(this.config);
+        if (maskSensitive && this.config.security?.maskSensitiveValues) {
+            return this.maskSensitiveValues(config);
+        }
+        return config;
+    }
+    /**
+   * Gets configuration with security masking applied
+   */ getSecure() {
+        return this.get(true);
+    }
+    /**
+   * Gets all configuration values (alias for get method for backward compatibility)
+   */ async getAll() {
+        return this.get();
+    }
+    /**
+   * Updates configuration values with change tracking
+   */ update(updates, options = {}) {
+        const oldConfig = deepClone(this.config);
+        // Track changes before applying
+        this.trackChanges(oldConfig, updates, options);
+        // Apply updates
+        this.config = deepMergeConfig(this.config, updates);
+        // Validate the updated configuration
+        this.validateWithDependencies(this.config);
+        return this.get();
+    }
+    /**
+   * Loads default configuration
+   */ loadDefault() {
+        this.config = deepClone(DEFAULT_CONFIG);
+    }
+    /**
+   * Saves configuration to file with format support
+   */ async save(path, format) {
+        const savePath = path || this.configPath;
+        if (!savePath) {
+            throw new ConfigError('No configuration file path specified');
+        }
+        const detectedFormat = format || this.detectFormat(savePath);
+        const parser = this.formatParsers[detectedFormat];
+        if (!parser) {
+            throw new ConfigError(`Unsupported format for saving: ${detectedFormat}`);
+        }
+        // Get configuration without sensitive values for saving
+        const configToSave = this.getConfigForSaving();
+        const content = parser.stringify(configToSave);
+        await fs.writeFile(savePath, content, 'utf8');
+        // Record the save operation
+        this.recordChange({
+            timestamp: new Date().toISOString(),
+            path: 'CONFIG_SAVED',
+            oldValue: null,
+            newValue: savePath,
+            source: 'file'
+        });
+    }
+    /**
+   * Gets configuration suitable for saving (excludes runtime-only values)
+   */ getConfigForSaving() {
+        const config = deepClone(this.config);
+        // Remove encrypted credentials from the saved config
+        // They should be stored separately in a secure location
+        if (config.credentials) {
+            delete config.credentials;
+        }
+        return config;
+    }
+    /**
+   * Gets user configuration directory
+   */ getUserConfigDir() {
+        const home = homedir();
+        return join(home, '.claude-flow');
+    }
+    /**
+   * Creates user config directory if it doesn't exist
+   */ async ensureUserConfigDir() {
+        try {
+            await fs.mkdir(this.userConfigDir, {
+                recursive: true
+            });
+        } catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw new ConfigError(`Failed to create config directory: ${error.message}`);
+            }
+        }
+    }
+    /**
+   * Loads all profiles from the profiles directory
+   */ async loadProfiles() {
+        const profilesDir = join(this.userConfigDir, 'profiles');
+        try {
+            const entries = await fs.readdir(profilesDir, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                if (entry.isFile() && entry.name.endsWith('.json')) {
+                    const profileName = entry.name.replace('.json', '');
+                    const profilePath = join(profilesDir, entry.name);
+                    try {
+                        const content = await fs.readFile(profilePath, 'utf8');
+                        const profileConfig = safeParseJSON(content);
+                        if (profileConfig) {
+                            this.profiles.set(profileName, profileConfig);
+                        }
+                    } catch (error) {
+                        console.warn(`Failed to load profile ${profileName}: ${error.message}`);
+                    }
+                }
+            }
+        } catch (error) {
+        // Profiles directory doesn't exist - this is okay
+        }
+    }
+    /**
+   * Applies a named profile
+   */ async applyProfile(profileName) {
+        await this.loadProfiles();
+        const profile = this.profiles.get(profileName);
+        if (!profile) {
+            throw new ConfigError(`Profile '${profileName}' not found`);
+        }
+        this.config = deepMergeConfig(this.config, profile);
+        this.currentProfile = profileName;
+        this.validate(this.config);
+    }
+    /**
+   * Saves current configuration as a profile
+   */ async saveProfile(profileName, config) {
+        await this.ensureUserConfigDir();
+        const profilesDir = join(this.userConfigDir, 'profiles');
+        await fs.mkdir(profilesDir, {
+            recursive: true
+        });
+        const profileConfig = config || this.config;
+        const profilePath = join(profilesDir, `${profileName}.json`);
+        const content = JSON.stringify(profileConfig, null, 2);
+        await fs.writeFile(profilePath, content, 'utf8');
+        this.profiles.set(profileName, profileConfig);
+    }
+    /**
+   * Deletes a profile
+   */ async deleteProfile(profileName) {
+        const profilePath = join(this.userConfigDir, 'profiles', `${profileName}.json`);
+        try {
+            await fs.unlink(profilePath);
+            this.profiles.delete(profileName);
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new ConfigError(`Profile '${profileName}' not found`);
+            }
+            throw new ConfigError(`Failed to delete profile: ${error.message}`);
+        }
+    }
+    /**
+   * Lists all available profiles
+   */ async listProfiles() {
+        await this.loadProfiles();
+        return Array.from(this.profiles.keys());
+    }
+    /**
+   * Gets a specific profile configuration
+   */ async getProfile(profileName) {
+        await this.loadProfiles();
+        return this.profiles.get(profileName);
+    }
+    /**
+   * Gets the current active profile name
+   */ getCurrentProfile() {
+        return this.currentProfile;
+    }
+    /**
+   * Sets a configuration value by path with change tracking and validation
+   */ set(path, value, options = {}) {
+        const oldValue = this.getValue(path);
+        // Record the change
+        this.recordChange({
+            timestamp: new Date().toISOString(),
+            path,
+            oldValue,
+            newValue: value,
+            user: options.user,
+            reason: options.reason,
+            source: options.source || 'cli'
+        });
+        // Encrypt sensitive values
+        if (this.isSensitivePath(path) && this.config.security?.encryptionEnabled) {
+            value = this.encryptValue(value);
+        }
+        const keys = path.split('.');
+        let current = this.config;
+        for(let i = 0; i < keys.length - 1; i++){
+            const key = keys[i];
+            if (!(key in current)) {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        current[keys[keys.length - 1]] = value;
+        // Validate the path-specific rule and dependencies
+        this.validatePath(path, value);
+        this.validateWithDependencies(this.config);
+    }
+    /**
+   * Gets a configuration value by path with decryption for sensitive values
+   */ getValue(path, decrypt = true) {
+        const keys = path.split('.');
+        let current = this.config;
+        for (const key of keys){
+            if (current && typeof current === 'object' && key in current) {
+                current = current[key];
+            } else {
+                return undefined;
+            }
+        }
+        // Decrypt sensitive values if requested
+        if (decrypt && this.isSensitivePath(path) && this.isEncryptedValue(current)) {
+            try {
+                return this.decryptValue(current);
+            } catch (error) {
+                console.warn(`Failed to decrypt value at path ${path}:`, error.message);
+                return current;
+            }
+        }
+        return current;
+    }
+    /**
+   * Resets configuration to defaults
+   */ reset() {
+        this.config = deepClone(DEFAULT_CONFIG);
+        delete this.currentProfile;
+    }
+    /**
+   * Gets configuration schema for validation
+   */ getSchema() {
+        return {
+            orchestrator: {
+                maxConcurrentAgents: {
+                    type: 'number',
+                    min: 1,
+                    max: 100
+                },
+                taskQueueSize: {
+                    type: 'number',
+                    min: 1,
+                    max: 10000
+                },
+                healthCheckInterval: {
+                    type: 'number',
+                    min: 1000,
+                    max: 300000
+                },
+                shutdownTimeout: {
+                    type: 'number',
+                    min: 1000,
+                    max: 300000
+                }
+            },
+            terminal: {
+                type: {
+                    type: 'string',
+                    values: [
+                        'auto',
+                        'vscode',
+                        'native'
+                    ]
+                },
+                poolSize: {
+                    type: 'number',
+                    min: 1,
+                    max: 50
+                },
+                recycleAfter: {
+                    type: 'number',
+                    min: 1,
+                    max: 1000
+                },
+                healthCheckInterval: {
+                    type: 'number',
+                    min: 1000,
+                    max: 3600000
+                },
+                commandTimeout: {
+                    type: 'number',
+                    min: 1000,
+                    max: 3600000
+                }
+            },
+            memory: {
+                backend: {
+                    type: 'string',
+                    values: [
+                        'sqlite',
+                        'markdown',
+                        'hybrid'
+                    ]
+                },
+                cacheSizeMB: {
+                    type: 'number',
+                    min: 1,
+                    max: 10000
+                },
+                syncInterval: {
+                    type: 'number',
+                    min: 1000,
+                    max: 300000
+                },
+                conflictResolution: {
+                    type: 'string',
+                    values: [
+                        'crdt',
+                        'timestamp',
+                        'manual'
+                    ]
+                },
+                retentionDays: {
+                    type: 'number',
+                    min: 1,
+                    max: 3650
+                }
+            },
+            coordination: {
+                maxRetries: {
+                    type: 'number',
+                    min: 0,
+                    max: 100
+                },
+                retryDelay: {
+                    type: 'number',
+                    min: 100,
+                    max: 60000
+                },
+                deadlockDetection: {
+                    type: 'boolean'
+                },
+                resourceTimeout: {
+                    type: 'number',
+                    min: 1000,
+                    max: 3600000
+                },
+                messageTimeout: {
+                    type: 'number',
+                    min: 1000,
+                    max: 300000
+                }
+            },
+            mcp: {
+                transport: {
+                    type: 'string',
+                    values: [
+                        'stdio',
+                        'http',
+                        'websocket'
+                    ]
+                },
+                port: {
+                    type: 'number',
+                    min: 1,
+                    max: 65535
+                },
+                tlsEnabled: {
+                    type: 'boolean'
+                }
+            },
+            logging: {
+                level: {
+                    type: 'string',
+                    values: [
+                        'debug',
+                        'info',
+                        'warn',
+                        'error'
+                    ]
+                },
+                format: {
+                    type: 'string',
+                    values: [
+                        'json',
+                        'text'
+                    ]
+                },
+                destination: {
+                    type: 'string',
+                    values: [
+                        'console',
+                        'file'
+                    ]
+                }
+            }
+        };
+    }
+    /**
+   * Validates a value against schema
+   */ validateValue(value, schema, path) {
+        if (schema.type === 'number') {
+            if (typeof value !== 'number' || isNaN(value)) {
+                throw new ValidationError(`${path}: must be a number`);
+            }
+            if (schema.min !== undefined && value < schema.min) {
+                throw new ValidationError(`${path}: must be at least ${schema.min}`);
+            }
+            if (schema.max !== undefined && value > schema.max) {
+                throw new ValidationError(`${path}: must be at most ${schema.max}`);
+            }
+        } else if (schema.type === 'string') {
+            if (typeof value !== 'string') {
+                throw new ValidationError(`${path}: must be a string`);
+            }
+            if (schema.values && !schema.values.includes(value)) {
+                throw new ValidationError(`${path}: must be one of [${schema.values.join(', ')}]`);
+            }
+        } else if (schema.type === 'boolean') {
+            if (typeof value !== 'boolean') {
+                throw new ValidationError(`${path}: must be a boolean`);
+            }
+        }
+    }
+    /**
+   * Gets configuration diff between current and default
+   */ getDiff() {
+        const defaultConfig = DEFAULT_CONFIG;
+        const diff = {};
+        const findDifferences = (current, defaults, path = '')=>{
+            for(const key in current){
+                const currentValue = current[key];
+                const defaultValue = defaults[key];
+                const fullPath = path ? `${path}.${key}` : key;
+                if (typeof currentValue === 'object' && currentValue !== null && !Array.isArray(currentValue)) {
+                    if (typeof defaultValue === 'object' && defaultValue !== null) {
+                        const nestedDiff = {};
+                        findDifferences(currentValue, defaultValue, fullPath);
+                        if (Object.keys(nestedDiff).length > 0) {
+                            if (!path) {
+                                diff[key] = nestedDiff;
+                            }
+                        }
+                    }
+                } else if (currentValue !== defaultValue) {
+                    const pathParts = fullPath.split('.');
+                    let target = diff;
+                    for(let i = 0; i < pathParts.length - 1; i++){
+                        if (!target[pathParts[i]]) {
+                            target[pathParts[i]] = {};
+                        }
+                        target = target[pathParts[i]];
+                    }
+                    target[pathParts[pathParts.length - 1]] = currentValue;
+                }
+            }
+        };
+        findDifferences(this.config, defaultConfig);
+        return diff;
+    }
+    /**
+   * Exports configuration with metadata
+   */ export() {
+        return {
+            version: '1.0.0',
+            exported: new Date().toISOString(),
+            profile: this.currentProfile,
+            config: this.config,
+            diff: this.getDiff()
+        };
+    }
+    /**
+   * Imports configuration from export
+   */ import(data) {
+        if (!data.config) {
+            throw new ConfigError('Invalid configuration export format');
+        }
+        this.validateWithDependencies(data.config);
+        this.config = data.config;
+        this.currentProfile = data.profile;
+        // Record the import operation
+        this.recordChange({
+            timestamp: new Date().toISOString(),
+            path: 'CONFIG_IMPORTED',
+            oldValue: null,
+            newValue: data.version || 'unknown',
+            source: 'file'
+        });
+    }
+    /**
+   * Loads configuration from file with format detection
+   */ async loadFromFile(path) {
+        try {
+            const content = await fs.readFile(path, 'utf8');
+            const format = this.detectFormat(path, content);
+            const parser = this.formatParsers[format];
+            if (!parser) {
+                throw new ConfigError(`Unsupported configuration format: ${format}`);
+            }
+            const config = parser.parse(content);
+            if (!config) {
+                throw new ConfigError(`Invalid ${format.toUpperCase()} in configuration file: ${path}`);
+            }
+            return config;
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, use defaults
+                return {};
+            }
+            throw new ConfigError(`Failed to load configuration from ${path}: ${error.message}`);
+        }
+    }
+    /**
+   * Detects configuration file format
+   */ detectFormat(path, content) {
+        const ext = path.split('.').pop()?.toLowerCase();
+        if (ext === 'yaml' || ext === 'yml') return 'yaml';
+        if (ext === 'toml') return 'toml';
+        if (ext === 'json') return 'json';
+        // Try to detect from content
+        if (content) {
+            const trimmed = content.trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[')) return 'json';
+            if (trimmed.includes('=') && trimmed.includes('[')) return 'toml';
+            if (trimmed.includes(':') && !trimmed.includes('=')) return 'yaml';
+        }
+        // Default to JSON
+        return 'json';
+    }
+    /**
+   * Loads configuration from environment variables
+   */ loadFromEnv() {
+        const config = {};
+        // Orchestrator settings
+        const maxAgents = process.env.CLAUDE_FLOW_MAX_AGENTS;
+        if (maxAgents) {
+            if (!config.orchestrator) {
+                config.orchestrator = {};
+            }
+            config.orchestrator = {
+                ...DEFAULT_CONFIG.orchestrator,
+                ...config.orchestrator,
+                maxConcurrentAgents: parseInt(maxAgents, 10)
+            };
+        }
+        // Terminal settings
+        const terminalType = process.env.CLAUDE_FLOW_TERMINAL_TYPE;
+        if (terminalType === 'vscode' || terminalType === 'native' || terminalType === 'auto') {
+            config.terminal = {
+                ...DEFAULT_CONFIG.terminal,
+                ...config.terminal,
+                type: terminalType
+            };
+        }
+        // Memory settings
+        const memoryBackend = process.env.CLAUDE_FLOW_MEMORY_BACKEND;
+        if (memoryBackend === 'sqlite' || memoryBackend === 'markdown' || memoryBackend === 'hybrid') {
+            config.memory = {
+                ...DEFAULT_CONFIG.memory,
+                ...config.memory,
+                backend: memoryBackend
+            };
+        }
+        // MCP settings
+        const mcpTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+        if (mcpTransport === 'stdio' || mcpTransport === 'http' || mcpTransport === 'websocket') {
+            config.mcp = {
+                ...DEFAULT_CONFIG.mcp,
+                ...config.mcp,
+                transport: mcpTransport
+            };
+        }
+        const mcpPort = process.env.CLAUDE_FLOW_MCP_PORT;
+        if (mcpPort) {
+            config.mcp = {
+                ...DEFAULT_CONFIG.mcp,
+                ...config.mcp,
+                port: parseInt(mcpPort, 10)
+            };
+        }
+        // Logging settings
+        const logLevel = process.env.CLAUDE_FLOW_LOG_LEVEL;
+        if (logLevel === 'debug' || logLevel === 'info' || logLevel === 'warn' || logLevel === 'error') {
+            config.logging = {
+                ...DEFAULT_CONFIG.logging,
+                ...config.logging,
+                level: logLevel
+            };
+        }
+        return config;
+    }
+    /**
+   * Validates configuration with dependency checking
+   */ validateWithDependencies(config) {
+        const errors = [];
+        const warnings = [];
+        // Validate all paths with rules
+        for (const [path, rule] of this.validationRules.entries()){
+            const value = this.getValueByPath(config, path);
+            try {
+                this.validatePath(path, value, config);
+            } catch (error) {
+                errors.push(error.message);
+            }
+        }
+        // Additional cross-field validations
+        if (config.orchestrator.maxConcurrentAgents > config.terminal.poolSize * 3) {
+            warnings.push('High agent-to-terminal ratio may cause resource contention');
+        }
+        if (config.memory.cacheSizeMB > 1000 && config.memory.backend === 'sqlite') {
+            warnings.push('Large cache size with SQLite backend may impact performance');
+        }
+        if (config.mcp.transport === 'http' && !config.mcp.tlsEnabled) {
+            warnings.push('HTTP transport without TLS is not recommended for production');
+        }
+        // Log warnings
+        if (warnings.length > 0 && config.logging?.level === 'debug') {
+            console.warn('Configuration warnings:', warnings);
+        }
+        // Throw errors
+        if (errors.length > 0) {
+            throw new ValidationError(`Configuration validation failed:\n${errors.join('\n')}`);
+        }
+    }
+    /**
+   * Validates a specific configuration path
+   */ validatePath(path, value, config) {
+        const rule = this.validationRules.get(path);
+        if (!rule) return;
+        const currentConfig = config || this.config;
+        // Required validation
+        if (rule.required && (value === undefined || value === null)) {
+            throw new ValidationError(`${path} is required`);
+        }
+        if (value === undefined || value === null) return;
+        // Type validation
+        if (rule.type === 'number' && (typeof value !== 'number' || isNaN(value))) {
+            throw new ValidationError(`${path} must be a number`);
+        }
+        if (rule.type === 'string' && typeof value !== 'string') {
+            throw new ValidationError(`${path} must be a string`);
+        }
+        if (rule.type === 'boolean' && typeof value !== 'boolean') {
+            throw new ValidationError(`${path} must be a boolean`);
+        }
+        // Range validation
+        if (typeof value === 'number') {
+            if (rule.min !== undefined && value < rule.min) {
+                throw new ValidationError(`${path} must be at least ${rule.min}`);
+            }
+            if (rule.max !== undefined && value > rule.max) {
+                throw new ValidationError(`${path} must be at most ${rule.max}`);
+            }
+        }
+        // Values validation
+        if (rule.values && !rule.values.includes(value)) {
+            throw new ValidationError(`${path} must be one of: ${rule.values.join(', ')}`);
+        }
+        // Pattern validation
+        if (rule.pattern && typeof value === 'string' && !rule.pattern.test(value)) {
+            throw new ValidationError(`${path} does not match required pattern`);
+        }
+        // Custom validator
+        if (rule.validator) {
+            const result = rule.validator(value, currentConfig);
+            if (result) {
+                throw new ValidationError(`${path}: ${result}`);
+            }
+        }
+    }
+    /**
+   * Gets a value from a configuration object by path
+   */ getValueByPath(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;
+    }
+    /**
+   * Legacy validate method for backward compatibility
+   */ validate(config) {
+        this.validateWithDependencies(config);
+    }
+    /**
+   * Masks sensitive values in configuration
+   */ maskSensitiveValues(config) {
+        const maskedConfig = deepClone(config);
+        // Recursively mask sensitive paths
+        const maskObject = (obj, path = '')=>{
+            if (!obj || typeof obj !== 'object') return obj;
+            const masked = {};
+            for (const [key, value] of Object.entries(obj)){
+                const currentPath = path ? `${path}.${key}` : key;
+                if (this.isSensitivePath(currentPath)) {
+                    const classification = SECURITY_CLASSIFICATIONS[currentPath];
+                    masked[key] = classification?.maskPattern || '****';
+                } else if (typeof value === 'object' && value !== null) {
+                    masked[key] = maskObject(value, currentPath);
+                } else {
+                    masked[key] = value;
+                }
+            }
+            return masked;
+        };
+        return maskObject(maskedConfig);
+    }
+    /**
+   * Tracks changes to configuration
+   */ trackChanges(oldConfig, updates, options) {
+        // Simple implementation for tracking changes
+        for (const [key, value] of Object.entries(updates)){
+            this.recordChange({
+                timestamp: new Date().toISOString(),
+                path: key,
+                oldValue: oldConfig[key],
+                newValue: value,
+                user: options.user,
+                reason: options.reason,
+                source: options.source || 'cli'
+            });
+        }
+    }
+    /**
+   * Records a configuration change
+   */ recordChange(change) {
+        this.changeHistory.push(change);
+        // Keep only last 1000 changes
+        if (this.changeHistory.length > 1000) {
+            this.changeHistory.shift();
+        }
+    }
+    /**
+   * Checks if a path contains sensitive information
+   */ isSensitivePath(path) {
+        return SENSITIVE_PATHS.some((sensitive)=>path.toLowerCase().includes(sensitive.toLowerCase()));
+    }
+    /**
+   * Encrypts a sensitive value
+   */ encryptValue(value) {
+        if (!this.encryptionKey) {
+            return value; // Return original if encryption not available
+        }
+        try {
+            // Simplified encryption - in production use proper encryption
+            const iv = randomBytes(16);
+            const key = createHash('sha256').update(this.encryptionKey).digest();
+            const cipher = createCipheriv('aes-256-cbc', key, iv);
+            let encrypted = cipher.update(JSON.stringify(value), 'utf8', 'hex');
+            encrypted += cipher.final('hex');
+            return `encrypted:${iv.toString('hex')}:${encrypted}`;
+        } catch (error) {
+            console.warn('Failed to encrypt value:', error.message);
+            return value;
+        }
+    }
+    /**
+   * Decrypts a sensitive value
+   */ decryptValue(encryptedValue) {
+        if (!this.encryptionKey || !this.isEncryptedValue(encryptedValue)) {
+            return encryptedValue;
+        }
+        try {
+            const parts = encryptedValue.replace('encrypted:', '').split(':');
+            if (parts.length !== 2) return encryptedValue; // Handle old format
+            const iv = Buffer.from(parts[0], 'hex');
+            const encrypted = parts[1];
+            const key = createHash('sha256').update(this.encryptionKey).digest();
+            const decipher = createDecipheriv('aes-256-cbc', key, iv);
+            let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return JSON.parse(decrypted);
+        } catch (error) {
+            console.warn('Failed to decrypt value:', error.message);
+            return encryptedValue;
+        }
+    }
+    /**
+   * Checks if a value is encrypted
+   */ isEncryptedValue(value) {
+        return typeof value === 'string' && value.startsWith('encrypted:');
+    }
+}
+// Export singleton instance
+export const configManager = ConfigManager.getInstance();
+// Helper function to load configuration
+export async function loadConfig(path) {
+    return await configManager.load(path);
+}
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+export { SENSITIVE_PATHS, SECURITY_CLASSIFICATIONS };
+// Custom deepMerge for Config type
+function deepMergeConfig(target, ...sources) {
+    const result = deepClone(target);
+    for (const source of sources){
+        if (!source) continue;
+        // Merge each section
+        if (source.orchestrator) {
+            result.orchestrator = {
+                ...result.orchestrator,
+                ...source.orchestrator
+            };
+        }
+        if (source.terminal) {
+            result.terminal = {
+                ...result.terminal,
+                ...source.terminal
+            };
+        }
+        if (source.memory) {
+            result.memory = {
+                ...result.memory,
+                ...source.memory
+            };
+        }
+        if (source.coordination) {
+            result.coordination = {
+                ...result.coordination,
+                ...source.coordination
+            };
+        }
+        if (source.mcp) {
+            result.mcp = {
+                ...result.mcp,
+                ...source.mcp
+            };
+        }
+        if (source.logging) {
+            result.logging = {
+                ...result.logging,
+                ...source.logging
+            };
+        }
+        if (source.credentials) {
+            result.credentials = {
+                ...result.credentials,
+                ...source.credentials
+            };
+        }
+        if (source.security) {
+            result.security = {
+                ...result.security,
+                ...source.security
+            };
+        }
+    }
+    return result;
+}
+
+//# sourceMappingURL=config.js.map