chrome-cdp-cli 1.8.1 → 2.0.0

package/dist/cli/demo-output-formatting.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env ts-node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateOutputFormats = demonstrateOutputFormats;
+const OutputManager_1 = require("./OutputManager");
+const OutputFormatter_1 = require("./OutputFormatter");
+const configs = {
+    text: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'text',
+        verbose: false,
+        quiet: false,
+        timeout: 30000,
+        debug: false
+    },
+    json: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'json',
+        verbose: false,
+        quiet: false,
+        timeout: 30000,
+        debug: false
+    },
+    yaml: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'yaml',
+        verbose: false,
+        quiet: false,
+        timeout: 30000,
+        debug: false
+    },
+    verbose: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'text',
+        verbose: true,
+        quiet: false,
+        timeout: 30000,
+        debug: false
+    },
+    quiet: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'text',
+        verbose: false,
+        quiet: true,
+        timeout: 30000,
+        debug: false
+    },
+    debug: {
+        host: 'localhost',
+        port: 9222,
+        outputFormat: 'text',
+        verbose: true,
+        quiet: false,
+        timeout: 30000,
+        debug: true
+    }
+};
+const sampleResults = {
+    simpleSuccess: {
+        success: true,
+        data: 'Operation completed successfully'
+    },
+    consoleMessages: {
+        success: true,
+        data: {
+            messages: [
+                {
+                    type: 'log',
+                    text: 'Application started',
+                    timestamp: Date.now() - 5000,
+                    args: []
+                },
+                {
+                    type: 'warn',
+                    text: 'Deprecated API usage detected',
+                    timestamp: Date.now() - 3000,
+                    args: ['api.old()']
+                },
+                {
+                    type: 'error',
+                    text: 'Failed to load resource',
+                    timestamp: Date.now() - 1000,
+                    args: ['https://example.com/missing.js']
+                }
+            ]
+        },
+        dataSource: 'proxy',
+        hasHistoricalData: true
+    },
+    networkRequests: {
+        success: true,
+        data: {
+            requests: [
+                {
+                    requestId: '1',
+                    url: 'https://api.example.com/users',
+                    method: 'GET',
+                    timestamp: Date.now() - 2000,
+                    status: 200
+                },
+                {
+                    requestId: '2',
+                    url: 'https://api.example.com/posts',
+                    method: 'POST',
+                    timestamp: Date.now() - 1000,
+                    status: 201
+                }
+            ]
+        },
+        dataSource: 'direct',
+        hasHistoricalData: false
+    },
+    error: {
+        success: false,
+        error: 'Connection timeout: Unable to connect to Chrome DevTools',
+        exitCode: 1
+    },
+    complexData: {
+        success: true,
+        data: {
+            pageInfo: {
+                title: 'Example Page',
+                url: 'https://example.com',
+                loadTime: 1250
+            },
+            metrics: {
+                domContentLoaded: 800,
+                firstPaint: 900,
+                firstContentfulPaint: 950
+            }
+        }
+    }
+};
+function printSeparator(title) {
+    console.log('\n' + '='.repeat(60));
+    console.log(`  ${title}`);
+    console.log('='.repeat(60));
+}
+function printSubsection(title) {
+    console.log(`\n--- ${title} ---`);
+}
+async function demonstrateOutputFormats() {
+    const outputManager = new OutputManager_1.OutputManager();
+    const formatter = new OutputFormatter_1.OutputFormatter();
+    printSeparator('STANDARDIZED OUTPUT FORMATTING DEMO');
+    printSubsection('1. Output Formats (JSON, Text, YAML)');
+    const result = sampleResults.complexData;
+    console.log('\n📄 TEXT FORMAT:');
+    console.log(outputManager.formatOutput(result, configs.text));
+    console.log('\n📋 JSON FORMAT:');
+    console.log(outputManager.formatOutput(result, configs.json));
+    console.log('\n📝 YAML FORMAT:');
+    console.log(outputManager.formatOutput(result, configs.yaml));
+    printSubsection('2. Verbose Mode with Timing Information');
+    const timing = (0, OutputFormatter_1.createTimingInfo)('screenshot-command', Date.now() - 1500, Date.now());
+    const metadata = {
+        command: 'screenshot',
+        args: { filename: 'test.png', fullPage: true },
+        config: configs.verbose
+    };
+    const enhancedResult = (0, OutputFormatter_1.enhanceCommandResult)(sampleResults.simpleSuccess, timing, metadata);
+    console.log('\n🔍 VERBOSE OUTPUT:');
+    console.log(formatter.formatOutput(enhancedResult, {
+        format: 'text',
+        mode: { verbose: true, quiet: false, debug: false },
+        includeMetadata: true,
+        includeTiming: true
+    }));
+    printSubsection('3. Quiet Mode (Minimal Output)');
+    console.log('\n🤫 QUIET MODE - Success with data:');
+    console.log(`"${outputManager.formatOutput(sampleResults.consoleMessages, configs.quiet)}"`);
+    console.log('\n🤫 QUIET MODE - Success without data:');
+    console.log(`"${outputManager.formatOutput(sampleResults.simpleSuccess, configs.quiet)}"`);
+    console.log('\n🤫 QUIET MODE - Error (still shown):');
+    console.log(outputManager.formatOutput(sampleResults.error, configs.quiet));
+    printSubsection('4. Debug Mode with Detailed Information');
+    const debugResult = (0, OutputFormatter_1.enhanceCommandResult)(sampleResults.error, timing, metadata);
+    console.log('\n🔧 DEBUG OUTPUT:');
+    console.log(formatter.formatOutput(debugResult, {
+        format: 'text',
+        mode: { verbose: true, quiet: false, debug: true },
+        includeMetadata: true,
+        includeTiming: true
+    }));
+    printSubsection('5. Console Messages Formatting');
+    console.log('\n📝 CONSOLE MESSAGES (Text):');
+    console.log(outputManager.formatOutput(sampleResults.consoleMessages, configs.text));
+    console.log('\n📝 CONSOLE MESSAGES (Verbose):');
+    console.log(outputManager.formatOutput(sampleResults.consoleMessages, configs.verbose));
+    printSubsection('6. Network Requests Formatting');
+    console.log('\n🌐 NETWORK REQUESTS:');
+    console.log(outputManager.formatOutput(sampleResults.networkRequests, configs.text));
+    printSubsection('7. Custom Output Templates');
+    formatter.registerTemplate({
+        name: 'status-only',
+        description: 'Show only success status',
+        template: 'Status: {{success}}',
+        variables: ['success']
+    });
+    formatter.registerTemplate({
+        name: 'detailed-summary',
+        description: 'Detailed summary with timing',
+        template: '✅ {{success}} | ⏱️ {{timing.duration}}ms | 📋 {{metadata.command}}',
+        variables: ['success', 'timing', 'metadata']
+    });
+    console.log('\n🎨 CUSTOM TEMPLATE - Status Only:');
+    console.log(formatter.formatOutput(sampleResults.simpleSuccess, {
+        format: 'text',
+        mode: { verbose: false, quiet: false, debug: false },
+        template: 'status-only'
+    }));
+    console.log('\n🎨 CUSTOM TEMPLATE - Detailed Summary:');
+    console.log(formatter.formatOutput(enhancedResult, {
+        format: 'text',
+        mode: { verbose: false, quiet: false, debug: false },
+        template: 'detailed-summary'
+    }));
+    printSubsection('8. Consistent Error Handling');
+    console.log('\n❌ ERROR (Text):');
+    console.log(outputManager.formatOutput(sampleResults.error, configs.text));
+    console.log('\n❌ ERROR (JSON):');
+    console.log(outputManager.formatOutput(sampleResults.error, configs.json));
+    console.log('\n❌ ERROR (Debug):');
+    console.log(outputManager.formatOutput(sampleResults.error, configs.debug));
+    printSubsection('9. Utility Functions');
+    console.log('\n🛠️ VALIDATION ERRORS:');
+    console.log(outputManager.formatValidationErrors([
+        { field: 'host', message: 'Invalid hostname format', suggestion: 'Use localhost or valid IP' },
+        { field: 'port', message: 'Port must be between 1 and 65535' }
+    ]));
+    console.log('\n📖 HELP INFORMATION:');
+    console.log(outputManager.formatHelpInfo('Screenshot Command', 'Capture a screenshot of the current page with various options.', [
+        'chrome-cdp-cli screenshot --filename=page.png',
+        'chrome-cdp-cli screenshot --full-page --format=jpeg'
+    ]));
+    printSubsection('10. Performance and Timing');
+    console.log('\n⏱️ TIMING INFORMATION:');
+    console.log(outputManager.getTimingInfo(Date.now() - 2500, Date.now(), 'complex-operation'));
+    console.log('\n📊 DATA SOURCE INFORMATION:');
+    console.log(outputManager.formatDataSourceInfo('proxy', true));
+    console.log(outputManager.formatDataSourceInfo('direct', false));
+    printSeparator('DEMO COMPLETE');
+    console.log('\n✅ All output formatting features demonstrated successfully!');
+    console.log('\n📋 Key Features:');
+    console.log('  • Multiple output formats (JSON, Text, YAML)');
+    console.log('  • Quiet and verbose modes');
+    console.log('  • Custom output templates');
+    console.log('  • Timing information for verbose mode');
+    console.log('  • Consistent error handling');
+    console.log('  • Smart data formatting (console messages, network requests)');
+    console.log('  • Debug mode with detailed information');
+    console.log('  • Utility functions for validation and help');
+}
+if (require.main === module) {
+    demonstrateOutputFormats().catch(console.error);
+}

package/dist/cli/index.js

@@ -1,12 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIApplication = exports.ExitCode = exports.CommandRouter = exports.CommandRegistry = exports.CLIInterface = void 0;
+exports.CommandRouter = exports.CommandRegistry = exports.CLIInterface = exports.CLIApplication = exports.CommandSchemaRegistry = exports.EnhancedCLIInterface = exports.ArgumentParser = void 0;
+var ArgumentParser_1 = require("./ArgumentParser");
+Object.defineProperty(exports, "ArgumentParser", { enumerable: true, get: function () { return ArgumentParser_1.ArgumentParser; } });
+var EnhancedCLIInterface_1 = require("./EnhancedCLIInterface");
+Object.defineProperty(exports, "EnhancedCLIInterface", { enumerable: true, get: function () { return EnhancedCLIInterface_1.EnhancedCLIInterface; } });
+var CommandSchemaRegistry_1 = require("./CommandSchemaRegistry");
+Object.defineProperty(exports, "CommandSchemaRegistry", { enumerable: true, get: function () { return CommandSchemaRegistry_1.CommandSchemaRegistry; } });
+__exportStar(require("./interfaces/ArgumentParser"), exports);
+var CLIApplication_1 = require("./CLIApplication");
+Object.defineProperty(exports, "CLIApplication", { enumerable: true, get: function () { return CLIApplication_1.CLIApplication; } });
 var CLIInterface_1 = require("./CLIInterface");
 Object.defineProperty(exports, "CLIInterface", { enumerable: true, get: function () { return CLIInterface_1.CLIInterface; } });
 var CommandRegistry_1 = require("./CommandRegistry");
 Object.defineProperty(exports, "CommandRegistry", { enumerable: true, get: function () { return CommandRegistry_1.CommandRegistry; } });
 var CommandRouter_1 = require("./CommandRouter");
 Object.defineProperty(exports, "CommandRouter", { enumerable: true, get: function () { return CommandRouter_1.CommandRouter; } });
-Object.defineProperty(exports, "ExitCode", { enumerable: true, get: function () { return CommandRouter_1.ExitCode; } });
-var CLIApplication_1 = require("./CLIApplication");
-Object.defineProperty(exports, "CLIApplication", { enumerable: true, get: function () { return CLIApplication_1.CLIApplication; } });

package/dist/cli/interfaces/ArgumentParser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/ConfigurationManager.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const interfaces_1 = require("./interfaces");
+class ConfigurationManager {
+    constructor() {
+        this.configSources = [];
+        this.availableProfiles = [];
+    }
+    async loadConfiguration(sources) {
+        this.configSources = sources.sort((a, b) => a.priority - b.priority);
+        let mergedConfig = { ...interfaces_1.DEFAULT_CLI_CONFIG };
+        for (const source of this.configSources) {
+            mergedConfig = this.mergeConfiguration(mergedConfig, source.data);
+        }
+        const validation = this.validateConfiguration(mergedConfig);
+        if (!validation.valid) {
+            const errorMessages = validation.errors.map(e => `${e.field}: ${e.message}`).join(', ');
+            throw new Error(`Configuration validation failed: ${errorMessages}`);
+        }
+        this.loadedConfig = mergedConfig;
+        return mergedConfig;
+    }
+    validateConfiguration(config) {
+        const errors = [];
+        const warnings = [];
+        if (!config.host || typeof config.host !== 'string') {
+            errors.push({
+                field: 'host',
+                message: 'Host must be a non-empty string',
+                code: 'INVALID_HOST',
+                suggestion: 'Use a valid hostname like "localhost" or IP address'
+            });
+        }
+        if (typeof config.port !== 'number' || config.port < 1 || config.port > 65535) {
+            errors.push({
+                field: 'port',
+                message: 'Port must be a number between 1 and 65535',
+                code: 'INVALID_PORT',
+                suggestion: 'Use a valid port number like 9222'
+            });
+        }
+        if (typeof config.timeout !== 'number' || config.timeout < 1) {
+            errors.push({
+                field: 'timeout',
+                message: 'Timeout must be a positive number',
+                code: 'INVALID_TIMEOUT',
+                suggestion: 'Use a timeout value in milliseconds, e.g., 30000'
+            });
+        }
+        const validFormats = ['json', 'text', 'yaml'];
+        if (!validFormats.includes(config.outputFormat)) {
+            errors.push({
+                field: 'outputFormat',
+                message: `Output format must be one of: ${validFormats.join(', ')}`,
+                code: 'INVALID_OUTPUT_FORMAT',
+                suggestion: 'Use "json", "text", or "yaml"'
+            });
+        }
+        const booleanFields = ['verbose', 'quiet', 'debug'];
+        for (const field of booleanFields) {
+            if (typeof config[field] !== 'boolean') {
+                errors.push({
+                    field,
+                    message: `${field} must be a boolean`,
+                    code: 'INVALID_BOOLEAN',
+                    suggestion: 'Use true or false'
+                });
+            }
+        }
+        if (!Array.isArray(config.pluginDirs)) {
+            errors.push({
+                field: 'pluginDirs',
+                message: 'Plugin directories must be an array',
+                code: 'INVALID_PLUGIN_DIRS',
+                suggestion: 'Use an array of directory paths'
+            });
+        }
+        else {
+            for (let i = 0; i < config.pluginDirs.length; i++) {
+                if (typeof config.pluginDirs[i] !== 'string') {
+                    errors.push({
+                        field: `pluginDirs[${i}]`,
+                        message: 'Plugin directory path must be a string',
+                        code: 'INVALID_PLUGIN_DIR_PATH',
+                        suggestion: 'Use a valid directory path'
+                    });
+                }
+            }
+        }
+        if (typeof config.aliases !== 'object' || config.aliases === null) {
+            errors.push({
+                field: 'aliases',
+                message: 'Aliases must be an object',
+                code: 'INVALID_ALIASES',
+                suggestion: 'Use an object with string keys and values'
+            });
+        }
+        else {
+            for (const [alias, command] of Object.entries(config.aliases)) {
+                if (typeof command !== 'string') {
+                    errors.push({
+                        field: `aliases.${alias}`,
+                        message: 'Alias target must be a string',
+                        code: 'INVALID_ALIAS_TARGET',
+                        suggestion: 'Use a valid command name'
+                    });
+                }
+            }
+        }
+        if (typeof config.commands !== 'object' || config.commands === null) {
+            errors.push({
+                field: 'commands',
+                message: 'Commands configuration must be an object',
+                code: 'INVALID_COMMANDS_CONFIG',
+                suggestion: 'Use an object with command names as keys'
+            });
+        }
+        if (config.verbose && config.quiet) {
+            warnings.push({
+                field: 'verbose,quiet',
+                message: 'Verbose and quiet modes are conflicting',
+                code: 'CONFLICTING_OPTIONS'
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    getConfigurationPrecedence() {
+        return [...this.configSources];
+    }
+    resolveConfigValue(key, type) {
+        if (!this.loadedConfig) {
+            throw new Error('Configuration not loaded. Call loadConfiguration first.');
+        }
+        const value = this.getNestedValue(this.loadedConfig, key);
+        if (value === undefined) {
+            throw new Error(`Configuration key "${key}" not found`);
+        }
+        if (!this.validateValueType(value, type)) {
+            throw new Error(`Configuration key "${key}" has invalid type. Expected ${type}, got ${typeof value}`);
+        }
+        return value;
+    }
+    async loadYAMLConfig(filePath) {
+        try {
+            const content = await fs.promises.readFile(filePath, 'utf-8');
+            let config;
+            try {
+                config = yaml.load(content);
+            }
+            catch (yamlError) {
+                config = JSON.parse(content);
+            }
+            if (typeof config !== 'object' || config === null) {
+                throw new Error('Configuration file must contain a valid object');
+            }
+            if (config.profiles) {
+                this.availableProfiles = Object.keys(config.profiles);
+            }
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to load configuration file "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    loadEnvironmentConfig() {
+        const envConfig = {};
+        const envMappings = {
+            [`${interfaces_1.ENV_PREFIX}HOST`]: 'host',
+            [`${interfaces_1.ENV_PREFIX}PORT`]: 'port',
+            [`${interfaces_1.ENV_PREFIX}TIMEOUT`]: 'timeout',
+            [`${interfaces_1.ENV_PREFIX}OUTPUT_FORMAT`]: 'outputFormat',
+            [`${interfaces_1.ENV_PREFIX}VERBOSE`]: 'verbose',
+            [`${interfaces_1.ENV_PREFIX}QUIET`]: 'quiet',
+            [`${interfaces_1.ENV_PREFIX}DEBUG`]: 'debug',
+            [`${interfaces_1.ENV_PREFIX}PROFILE`]: 'profile',
+            [`${interfaces_1.ENV_PREFIX}CONFIG_FILE`]: 'configFile'
+        };
+        for (const [envVar, configKey] of Object.entries(envMappings)) {
+            const value = process.env[envVar];
+            if (value !== undefined) {
+                envConfig[configKey] = this.parseEnvironmentValue(value, configKey);
+            }
+        }
+        const pluginDirs = process.env[`${interfaces_1.ENV_PREFIX}PLUGIN_DIRS`];
+        if (pluginDirs) {
+            envConfig.pluginDirs = pluginDirs.split(',').map(dir => dir.trim());
+        }
+        return {
+            type: 'env',
+            priority: interfaces_1.CONFIG_PRIORITIES.env,
+            data: envConfig,
+            source: 'environment variables'
+        };
+    }
+    getAvailableProfiles() {
+        return [...this.availableProfiles];
+    }
+    async loadProfile(profileName) {
+        const configFiles = await this.findConfigurationFiles();
+        for (const configFile of configFiles) {
+            try {
+                const config = await this.loadYAMLConfig(configFile);
+                if (config.profiles && config.profiles[profileName]) {
+                    return config.profiles[profileName];
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+        throw new Error(`Profile "${profileName}" not found in any configuration file`);
+    }
+    async createConfigurationSources(cliOptions = {}) {
+        const sources = [];
+        sources.push({
+            type: 'default',
+            priority: interfaces_1.CONFIG_PRIORITIES.default,
+            data: { ...interfaces_1.DEFAULT_CLI_CONFIG },
+            source: 'defaults'
+        });
+        const configFile = cliOptions.configFile || await this.findDefaultConfigFile();
+        if (configFile) {
+            try {
+                const fileConfig = await this.loadYAMLConfig(configFile);
+                let profileConfig = {};
+                const profileName = cliOptions.profile || fileConfig.profile;
+                if (profileName && fileConfig.profiles && fileConfig.profiles[profileName]) {
+                    profileConfig = fileConfig.profiles[profileName];
+                }
+                const mergedFileConfig = this.mergeConfiguration(fileConfig, profileConfig);
+                sources.push({
+                    type: 'file',
+                    priority: interfaces_1.CONFIG_PRIORITIES.file,
+                    data: mergedFileConfig,
+                    source: configFile
+                });
+            }
+            catch (error) {
+                if (cliOptions.configFile) {
+                    throw error;
+                }
+            }
+        }
+        sources.push(this.loadEnvironmentConfig());
+        sources.push({
+            type: 'cli',
+            priority: interfaces_1.CONFIG_PRIORITIES.cli,
+            data: cliOptions,
+            source: 'command line'
+        });
+        return sources;
+    }
+    async findConfigurationFiles() {
+        const configFiles = [];
+        for (const searchPath of interfaces_1.DEFAULT_CONFIG_PATHS) {
+            for (const fileName of interfaces_1.DEFAULT_CONFIG_FILES) {
+                const filePath = path.join(searchPath, fileName);
+                try {
+                    await fs.promises.access(filePath, fs.constants.R_OK);
+                    configFiles.push(filePath);
+                }
+                catch {
+                }
+            }
+        }
+        return configFiles;
+    }
+    async findDefaultConfigFile() {
+        const configFiles = await this.findConfigurationFiles();
+        return configFiles.length > 0 ? configFiles[0] : null;
+    }
+    mergeConfiguration(base, override) {
+        const result = { ...base };
+        for (const [key, value] of Object.entries(override)) {
+            if (value !== undefined && value !== null) {
+                if (typeof value === 'object' && !Array.isArray(value) && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+                    result[key] = this.mergeConfiguration(result[key], value);
+                }
+                else {
+                    result[key] = value;
+                }
+            }
+        }
+        return result;
+    }
+    parseEnvironmentValue(value, key) {
+        if (['verbose', 'quiet', 'debug'].includes(key)) {
+            return value.toLowerCase() === 'true' || value === '1';
+        }
+        if (['port', 'timeout'].includes(key)) {
+            const num = parseInt(value, 10);
+            return isNaN(num) ? value : num;
+        }
+        return value;
+    }
+    getNestedValue(obj, key) {
+        return key.split('.').reduce((current, prop) => current?.[prop], obj);
+    }
+    validateValueType(value, expectedType) {
+        switch (expectedType) {
+            case 'string':
+                return typeof value === 'string';
+            case 'number':
+                return typeof value === 'number';
+            case 'boolean':
+                return typeof value === 'boolean';
+            case 'array':
+                return Array.isArray(value);
+            case 'object':
+                return typeof value === 'object' && value !== null && !Array.isArray(value);
+            default:
+                return false;
+        }
+    }
+}
+exports.ConfigurationManager = ConfigurationManager;