@daniel.stefan/metalink 1.3.1

package/packages/core/dist/config/loader.js

@@ -0,0 +1,777 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { validateConfig, } from './schema.js';
+/**
+ * ConfigLoader - Handles loading and validation of metalink configurations
+ * Supports YAML and JSON formats with environment variable interpolation
+ */
+export class ConfigLoader {
+    constructor(configPath) {
+        this.config = null;
+        // Priority: provided path > METALINK_CONFIG env > default locations
+        this.configPath =
+            configPath ||
+                process.env.METALINK_CONFIG ||
+                this.findDefaultConfigPath();
+    }
+    /**
+     * Finds default config location
+     * Tries: ./metalink.config.yaml, ./metalink.config.json, ~/.config/metalink/config.yaml
+     */
+    findDefaultConfigPath() {
+        const candidates = [
+            path.join(process.cwd(), 'metalink.config.yaml'),
+            path.join(process.cwd(), 'metalink.config.json'),
+            path.join(process.env.HOME || '~', '.config', 'metalink', 'config.yaml'),
+            path.join(process.env.HOME || '~', '.config', 'metalink', 'config.json'),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Return default if none exist (will fail gracefully on load)
+        return path.join(process.cwd(), 'metalink.config.yaml');
+    }
+    /**
+     * Load configuration from file
+     */
+    async load() {
+        if (this.config) {
+            return this.config;
+        }
+        if (!fs.existsSync(this.configPath)) {
+            throw new Error(`Config file not found: ${this.configPath}`);
+        }
+        const fileContent = fs.readFileSync(this.configPath, 'utf-8');
+        let parsed;
+        try {
+            // Detect format based on file extension
+            if (this.configPath.endsWith('.yaml') || this.configPath.endsWith('.yml')) {
+                parsed = yaml.load(fileContent);
+            }
+            else if (this.configPath.endsWith('.json')) {
+                parsed = JSON.parse(fileContent);
+            }
+            else {
+                // Try YAML first, fall back to JSON
+                try {
+                    parsed = yaml.load(fileContent);
+                }
+                catch {
+                    parsed = JSON.parse(fileContent);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse config file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Interpolate environment variables
+        const interpolated = this.interpolateEnv(parsed);
+        // Validate against schema
+        try {
+            this.config = validateConfig(interpolated);
+            // v1.3.59: Load base_servers from registry immediately after config validation
+            this.loadBaseServersFromRegistry();
+            return this.config;
+        }
+        catch (error) {
+            throw new Error(`Config validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Load config synchronously
+     */
+    loadSync() {
+        if (this.config) {
+            return this.config;
+        }
+        if (!fs.existsSync(this.configPath)) {
+            throw new Error(`Config file not found: ${this.configPath}`);
+        }
+        const fileContent = fs.readFileSync(this.configPath, 'utf-8');
+        let parsed;
+        try {
+            if (this.configPath.endsWith('.yaml') || this.configPath.endsWith('.yml')) {
+                parsed = yaml.load(fileContent);
+            }
+            else if (this.configPath.endsWith('.json')) {
+                parsed = JSON.parse(fileContent);
+            }
+            else {
+                try {
+                    parsed = yaml.load(fileContent);
+                }
+                catch {
+                    parsed = JSON.parse(fileContent);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse config file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const interpolated = this.interpolateEnv(parsed);
+        try {
+            this.config = validateConfig(interpolated);
+            // v1.3.59: Load base_servers from registry immediately after config validation
+            this.loadBaseServersFromRegistry();
+            return this.config;
+        }
+        catch (error) {
+            throw new Error(`Config validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Load base_servers from mcp-registry.json and merge into config
+     * v1.3.59: Registry is source of truth for base_servers
+     */
+    loadBaseServersFromRegistry() {
+        if (!this.config)
+            return;
+        const registryPath = this.getRegistryPath();
+        if (!fs.existsSync(registryPath))
+            return;
+        try {
+            const registryContent = fs.readFileSync(registryPath, 'utf8');
+            const registry = JSON.parse(registryContent);
+            if (registry.base_servers && Array.isArray(registry.base_servers)) {
+                this.config.base_servers = registry.base_servers;
+            }
+        }
+        catch {
+            // Registry read failed, use config defaults
+        }
+    }
+    /**
+     * Interpolate environment variables in config
+     * Supports ${VAR_NAME} and ${secret:KEY} syntax
+     */
+    interpolateEnv(obj) {
+        if (typeof obj === 'string') {
+            // Handle ${VAR_NAME} syntax
+            return obj.replace(/\$\{([^}]+)\}/g, (match, key) => {
+                if (key.startsWith('secret:')) {
+                    // Secrets are resolved separately (prepare placeholder)
+                    return match; // Keep as-is for secret resolution phase
+                }
+                return process.env[key] || match;
+            });
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            if (Array.isArray(obj)) {
+                return obj.map((item) => this.interpolateEnv(item));
+            }
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.interpolateEnv(value);
+            }
+            return result;
+        }
+        return obj;
+    }
+    /**
+     * Get specific server configuration by name
+     */
+    getServer(name) {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call load() or loadSync() first.');
+        }
+        // Check config servers first
+        let server = this.config.servers?.find((s) => s.name === name);
+        if (server)
+            return server;
+        // Check persistent registry if available
+        const registryPath = this.getRegistryPath();
+        if (fs.existsSync(registryPath)) {
+            try {
+                const registryContent = fs.readFileSync(registryPath, 'utf8');
+                const registry = JSON.parse(registryContent);
+                server = registry.servers?.find((s) => s.name === name);
+                if (server)
+                    return server;
+            }
+            catch (error) {
+                console.warn(`Failed to load registry from ${registryPath}:`, error);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get daemon configuration
+     */
+    getDaemon() {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call load() or loadSync() first.');
+        }
+        return (this.config.daemon || {
+            port: 3000,
+            host: '0.0.0.0',
+            logLevel: 'info',
+            auth: { enabled: false, type: 'bearer' },
+            rateLimit: { enabled: true, windowMs: 60000, max: 500, keyGenerator: 'ip' },
+        });
+    }
+    /**
+     * Get all available servers (including those not currently exposed)
+     */
+    getAllServers() {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call load() or loadSync() first.');
+        }
+        // Start with config servers
+        let servers = [...(this.config.servers || [])];
+        // Migrate registry from old location if needed (one-time migration)
+        this.migrateRegistry();
+        // Load from persistent mcp-registry.json location
+        const registryPath = this.getRegistryPath();
+        if (fs.existsSync(registryPath)) {
+            try {
+                const registryContent = fs.readFileSync(registryPath, 'utf8');
+                const registry = JSON.parse(registryContent);
+                // Add registry servers (avoid duplicates)
+                const configNames = new Set(servers.map(s => s.name));
+                for (const server of registry.servers || []) {
+                    if (!configNames.has(server.name)) {
+                        servers.push(server);
+                    }
+                }
+            }
+            catch {
+                // Registry read failed, use config servers only
+            }
+        }
+        return servers;
+    }
+    /**
+     * Get all servers from registry
+     * v1.3.58: Removed expose_servers/disable_servers filtering - all servers in registry are available
+     * Use base_servers config to control which servers auto-start on daemon init
+     */
+    getServers() {
+        return this.getAllServers();
+    }
+    /**
+     * Get configuration by profile name
+     */
+    getProfile(profileName) {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call load() or loadSync() first.');
+        }
+        return this.config.profiles?.find((p) => p.name === profileName);
+    }
+    /**
+     * Set current config (useful for testing)
+     */
+    setConfig(config) {
+        this.config = config;
+    }
+    /**
+     * Get currently loaded config
+     */
+    getConfig() {
+        if (!this.config) {
+            // Auto-load if cache was invalidated to prevent "Config not loaded" errors
+            this.config = this.loadSync();
+        }
+        return this.config;
+    }
+    /**
+     * Get base servers (read from config, never hardcoded)
+     * These servers are directly exposed in tools/list and auto-started on daemon init
+     */
+    getBaseServers() {
+        const config = this.getConfig();
+        return config.base_servers || [
+            'memory',
+            'time',
+            'fetch',
+            'sequential-thinking',
+            'duckduckgo',
+            'sysinstruct',
+        ];
+    }
+    /**
+     * Get tool safety classification rules
+     * Used to determine if a tool requires execute_tool (safe) or execute_tool_confirm (risky)
+     * Reads from mcp-registry.json tool_safety section (NOT from config file)
+     */
+    getToolSafetyRules() {
+        // Read from mcp-registry.json (where toolSafetyRules is defined)
+        const registryPath = this.getRegistryPath();
+        let toolSafety = null;
+        try {
+            // Use synchronous fs.readFileSync (fs already imported at top)
+            const registryContent = fs.readFileSync(registryPath, 'utf8');
+            const registry = JSON.parse(registryContent);
+            toolSafety = registry.toolSafetyRules;
+        }
+        catch {
+            // Registry file doesn't exist or can't be read - use defaults
+        }
+        // Return tool_safety from registry or defaults
+        return toolSafety || {
+            safePatterns: [
+                '.*search.*',
+                '.*list.*',
+                '.*get.*',
+                '.*read.*',
+                '.*fetch.*',
+                '.*describe.*',
+                '.*find.*',
+                '.*status.*',
+                '.*query.*',
+                '.*open.*', // Added: open_nodes and similar read operations
+                '.*convert.*', // Added: convert_time and similar transformations
+            ],
+            riskyPatterns: [
+                '.*create.*',
+                '.*delete.*',
+                '.*update.*',
+                '.*execute.*',
+                '.*write.*',
+                '.*commit.*',
+                '.*add.*',
+                '.*remove.*',
+                '.*set.*',
+                '.*modify.*',
+                '.*change.*',
+                '.*insert.*',
+                '.*drop.*',
+                '.*alter.*',
+            ],
+            safeToolOverrides: [
+                'memory:open_nodes', // Read/query operation
+                'time:convert_time', // Safe transformation
+                'sequential-thinking:sequentialthinking', // Read-only reasoning
+                // Note: Server-specific overrides (e.g., meta*:retrieve) should be in user's
+                // mcp-registry.json toolSafetyRules, not hardcoded here
+            ],
+            riskyToolOverrides: [
+                'time:wait', // Time delay can be used maliciously
+            ],
+            // v1.1.55: Argument inspection rules for SQL-based tools
+            // Supports wildcards (*, ?) for matching multiple server instances
+            // Note: Server-specific rules (e.g., meta*:execute) should be in user's
+            // mcp-registry.json toolSafetyRules, not hardcoded here
+            argumentInspectionRules: [],
+        };
+    }
+    /**
+     * Set tool safety rules in registry with atomic write and backup
+     * Phase 1: Core persistence method
+     */
+    async setToolSafetyRules(rules) {
+        const registryPath = this.getRegistryPath();
+        const registryDir = path.dirname(registryPath);
+        // Ensure directory exists
+        if (!fs.existsSync(registryDir)) {
+            fs.mkdirSync(registryDir, { recursive: true });
+        }
+        try {
+            let registry = {};
+            // Read existing registry if it exists
+            if (fs.existsSync(registryPath)) {
+                const registryContent = fs.readFileSync(registryPath, 'utf8');
+                registry = JSON.parse(registryContent);
+            }
+            // Merge new rules with existing registry
+            registry.toolSafetyRules = {
+                ...registry.toolSafetyRules,
+                ...rules,
+            };
+            // Create backup before write
+            const backupPath = `${registryPath}.backup`;
+            if (fs.existsSync(registryPath)) {
+                fs.copyFileSync(registryPath, backupPath);
+            }
+            // Atomic write: write to temp file, then rename
+            const tempPath = `${registryPath}.tmp`;
+            fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2), 'utf8');
+            fs.renameSync(tempPath, registryPath);
+            // Invalidate cache to force reload
+            this.invalidateCache();
+        }
+        catch (error) {
+            throw new Error(`Failed to set tool safety rules: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Add a safe tool override
+     */
+    async addSafeToolOverride(tool) {
+        if (!this.validateToolFormat(tool)) {
+            throw new Error(`Invalid tool format: ${tool}. Expected format: server:tool or server:*`);
+        }
+        const rules = this.getToolSafetyRules();
+        rules.safeToolOverrides = rules.safeToolOverrides || [];
+        // Add if not already present (no duplicates)
+        if (!rules.safeToolOverrides.includes(tool)) {
+            rules.safeToolOverrides.push(tool);
+            await this.setToolSafetyRules(rules);
+        }
+    }
+    /**
+     * Remove a safe tool override
+     */
+    async removeSafeToolOverride(tool) {
+        const rules = this.getToolSafetyRules();
+        if (rules.safeToolOverrides) {
+            const originalLength = rules.safeToolOverrides.length;
+            rules.safeToolOverrides = rules.safeToolOverrides.filter((t) => t !== tool);
+            // Only write if something was actually removed
+            if (rules.safeToolOverrides.length < originalLength) {
+                await this.setToolSafetyRules(rules);
+            }
+        }
+    }
+    /**
+     * Add a risky tool override
+     */
+    async addRiskyToolOverride(tool) {
+        if (!this.validateToolFormat(tool)) {
+            throw new Error(`Invalid tool format: ${tool}. Expected format: server:tool or server:*`);
+        }
+        const rules = this.getToolSafetyRules();
+        rules.riskyToolOverrides = rules.riskyToolOverrides || [];
+        // Add if not already present (no duplicates)
+        if (!rules.riskyToolOverrides.includes(tool)) {
+            rules.riskyToolOverrides.push(tool);
+            await this.setToolSafetyRules(rules);
+        }
+    }
+    /**
+     * Remove a risky tool override
+     */
+    async removeRiskyToolOverride(tool) {
+        const rules = this.getToolSafetyRules();
+        if (rules.riskyToolOverrides) {
+            const originalLength = rules.riskyToolOverrides.length;
+            rules.riskyToolOverrides = rules.riskyToolOverrides.filter((t) => t !== tool);
+            // Only write if something was actually removed
+            if (rules.riskyToolOverrides.length < originalLength) {
+                await this.setToolSafetyRules(rules);
+            }
+        }
+    }
+    /**
+     * Add a safe pattern
+     */
+    async addSafePattern(pattern) {
+        if (!this.validateRegexPattern(pattern)) {
+            throw new Error(`Invalid regex pattern: ${pattern}`);
+        }
+        const rules = this.getToolSafetyRules();
+        rules.safePatterns = rules.safePatterns || [];
+        // Add if not already present
+        if (!rules.safePatterns.includes(pattern)) {
+            rules.safePatterns.push(pattern);
+            await this.setToolSafetyRules(rules);
+        }
+    }
+    /**
+     * Remove a safe pattern
+     */
+    async removeSafePattern(pattern) {
+        const rules = this.getToolSafetyRules();
+        if (rules.safePatterns) {
+            const originalLength = rules.safePatterns.length;
+            rules.safePatterns = rules.safePatterns.filter((p) => p !== pattern);
+            // Only write if something was actually removed
+            if (rules.safePatterns.length < originalLength) {
+                await this.setToolSafetyRules(rules);
+            }
+        }
+    }
+    /**
+     * Add a risky pattern
+     */
+    async addRiskyPattern(pattern) {
+        if (!this.validateRegexPattern(pattern)) {
+            throw new Error(`Invalid regex pattern: ${pattern}`);
+        }
+        const rules = this.getToolSafetyRules();
+        rules.riskyPatterns = rules.riskyPatterns || [];
+        // Add if not already present
+        if (!rules.riskyPatterns.includes(pattern)) {
+            rules.riskyPatterns.push(pattern);
+            await this.setToolSafetyRules(rules);
+        }
+    }
+    /**
+     * Remove a risky pattern
+     */
+    async removeRiskyPattern(pattern) {
+        const rules = this.getToolSafetyRules();
+        if (rules.riskyPatterns) {
+            const originalLength = rules.riskyPatterns.length;
+            rules.riskyPatterns = rules.riskyPatterns.filter((p) => p !== pattern);
+            // Only write if something was actually removed
+            if (rules.riskyPatterns.length < originalLength) {
+                await this.setToolSafetyRules(rules);
+            }
+        }
+    }
+    /**
+     * Reset safety rules to defaults
+     */
+    async resetToDefaults() {
+        const registryPath = this.getRegistryPath();
+        const backupPath = `${registryPath}.backup.before-reset`;
+        try {
+            // Create backup before reset
+            if (fs.existsSync(registryPath)) {
+                fs.copyFileSync(registryPath, backupPath);
+            }
+            // Get current argumentInspectionRules to preserve them (v1.1.29)
+            const currentRules = this.getToolSafetyRules();
+            const argumentInspectionRules = currentRules.argumentInspectionRules || [];
+            // Reset to defaults (but preserve argumentInspectionRules)
+            const defaults = {
+                safePatterns: [
+                    '.*search.*',
+                    '.*list.*',
+                    '.*get.*',
+                    '.*read.*',
+                    '.*fetch.*',
+                    '.*describe.*',
+                    '.*find.*',
+                    '.*status.*',
+                    '.*query.*',
+                ],
+                riskyPatterns: [
+                    '.*create.*',
+                    '.*delete.*',
+                    '.*update.*',
+                    '.*execute.*',
+                    '.*write.*',
+                    '.*commit.*',
+                    '.*add.*',
+                    '.*remove.*',
+                    '.*set.*',
+                    '.*modify.*',
+                    '.*change.*',
+                    '.*insert.*',
+                    '.*drop.*',
+                    '.*alter.*',
+                ],
+                safeToolOverrides: [],
+                riskyToolOverrides: [],
+            };
+            // Preserve argumentInspectionRules if they exist (v1.1.29)
+            if (argumentInspectionRules.length > 0) {
+                defaults.argumentInspectionRules = argumentInspectionRules;
+            }
+            await this.setToolSafetyRules(defaults);
+        }
+        catch (error) {
+            throw new Error(`Failed to reset safety rules: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Validate tool format (server:tool or server:*)
+     */
+    validateToolFormat(tool) {
+        const pattern = /^[a-zA-Z0-9_-]+:[a-zA-Z0-9_*-]+$/;
+        return pattern.test(tool);
+    }
+    /**
+     * Validate regex pattern (try to compile it)
+     */
+    validateRegexPattern(pattern) {
+        try {
+            new RegExp(pattern);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Reload configuration
+     */
+    async reload() {
+        this.config = null;
+        return this.load();
+    }
+    /**
+     * Invalidate config cache and reload
+     * Used after registry changes to ensure fresh config
+     */
+    invalidateCache() {
+        this.config = null;
+        // Auto-reload immediately to prevent "Config not loaded" errors
+        this.loadSync();
+    }
+    /**
+     * Get the persistent registry file path
+     * Defaults to ~/.config/metalink/mcp-registry.json
+     * Respects METALINK_CONFIG_DIR environment variable if set
+     */
+    getRegistryPath() {
+        const configDir = process.env.METALINK_CONFIG_DIR ||
+            path.join(process.env.HOME || process.env.USERPROFILE || '~', '.config', 'metalink');
+        return path.join(configDir, 'mcp-registry.json');
+    }
+    /**
+     * Migrate registry from old location (current dir) to persistent location if needed
+     * This is called on first run to preserve user-added servers
+     */
+    migrateRegistry() {
+        const oldRegistryPath = path.join(process.cwd(), 'mcp-registry.json');
+        const newRegistryPath = this.getRegistryPath();
+        // Skip if old registry doesn't exist
+        if (!fs.existsSync(oldRegistryPath)) {
+            return;
+        }
+        // Skip if new registry already exists (migration already done)
+        if (fs.existsSync(newRegistryPath)) {
+            return;
+        }
+        try {
+            // Ensure new directory exists
+            const registryDir = path.dirname(newRegistryPath);
+            if (!fs.existsSync(registryDir)) {
+                fs.mkdirSync(registryDir, { recursive: true });
+            }
+            // Copy registry to new location
+            fs.copyFileSync(oldRegistryPath, newRegistryPath);
+            console.log(`[ConfigLoader] Migrated registry from ${oldRegistryPath} to ${newRegistryPath}`);
+        }
+        catch (error) {
+            console.warn(`[ConfigLoader] Failed to migrate registry: ${error instanceof Error ? error.message : String(error)}`);
+            // Don't throw - migration failure shouldn't break startup
+        }
+    }
+    /**
+     * Save a new server to the registry file
+     * Automatically invalidates config cache to force reload
+     */
+    async saveServerToRegistry(config, options = {}) {
+        const { RegistryManager } = await import('./registry.js');
+        const registryPath = this.getRegistryPath();
+        const registry = new RegistryManager(registryPath);
+        const server = await registry.addServer(config, options);
+        // Invalidate cache so next load picks up the new server
+        this.invalidateCache();
+        return server;
+    }
+    /**
+     * Remove a server from the registry file
+     * Automatically invalidates config cache to force reload
+     */
+    async removeServerFromRegistry(name, options = {}) {
+        const { RegistryManager } = await import('./registry.js');
+        const registryPath = this.getRegistryPath();
+        const registry = new RegistryManager(registryPath);
+        await registry.removeServer(name, options);
+        // Invalidate cache so next load picks up the removal
+        this.invalidateCache();
+    }
+    /**
+     * Create config from object (useful for testing)
+     */
+    static fromObject(obj) {
+        const loader = new ConfigLoader();
+        loader.setConfig(obj);
+        return loader;
+    }
+    /**
+     * Create and load config from file path
+     */
+    static async loadFrom(filePath) {
+        const loader = new ConfigLoader(filePath);
+        await loader.load();
+        return loader;
+    }
+    /**
+     * Create and load config from file path synchronously
+     */
+    static loadFromSync(filePath) {
+        const loader = new ConfigLoader(filePath);
+        loader.loadSync();
+        return loader;
+    }
+    /**
+     * Load from environment variables (fallback mechanism)
+     * Uses METALINK_* prefixed env vars
+     */
+    static fromEnv() {
+        const config = {
+            version: '1.0.0',
+            daemon: {
+                port: parseInt(process.env.METALINK_PORT || '3000', 10),
+                host: process.env.METALINK_HOST || '0.0.0.0',
+                logLevel: process.env.METALINK_LOG_LEVEL || 'info',
+                auth: { enabled: false, type: 'bearer' },
+                rateLimit: { enabled: true, windowMs: 60000, max: 500, keyGenerator: 'ip' },
+            },
+            servers: [],
+            plugins: [],
+            profiles: [],
+            environment: {},
+            secrets: { provider: 'env', keyringService: 'metalink' },
+            schemasCacheTTL: parseInt(process.env.METALINK_SCHEMAS_CACHE_TTL || '300000', 10), // Default 5 minutes
+            schemasCachePath: process.env.METALINK_SCHEMAS_CACHE_PATH || '~/.config/metalink/schemas', // v1.3.62: Global cache
+            maxSchemaCacheEntries: parseInt(process.env.METALINK_MAX_SCHEMA_CACHE_ENTRIES || '100', 10), // Default 100 entries
+            schemasBackgroundRefresh: process.env.METALINK_SCHEMAS_BACKGROUND_REFRESH !== 'false', // Default true
+            backgroundSchemaPopulation: process.env.METALINK_BACKGROUND_SCHEMA_POPULATION === 'true', // Default false (v1.3.62)
+            dynamicToolExposure: process.env.METALINK_DYNAMIC_TOOL_EXPOSURE === 'true', // Default false (v1.3.51 Speakeasy)
+            base_servers_auto_start: process.env.METALINK_BASE_SERVERS_AUTO_START !== 'false', // Default true (v1.3.57)
+            base_servers_auto_expose_tools: process.env.METALINK_BASE_SERVERS_AUTO_EXPOSE_TOOLS === 'true', // Default false (v1.3.57)
+            timeouts: {
+                serverInit: parseInt(process.env.METALINK_TIMEOUT_INIT || '10000', 10),
+                toolFetch: parseInt(process.env.METALINK_TIMEOUT_TOOL_FETCH || '60000', 10),
+                toolExecution: parseInt(process.env.METALINK_TIMEOUT_TOOL_EXECUTION || '300000', 10),
+                gracefulShutdown: parseInt(process.env.METALINK_TIMEOUT_SHUTDOWN || '5000', 10),
+            },
+            circuitBreaker: {
+                failureThreshold: parseInt(process.env.METALINK_CIRCUIT_BREAKER_FAILURE_THRESHOLD || '3', 10),
+                resetTimeout: parseInt(process.env.METALINK_CIRCUIT_BREAKER_RESET_TIMEOUT || '30000', 10),
+                halfOpenSuccessThreshold: parseInt(process.env.METALINK_CIRCUIT_BREAKER_HALF_OPEN_SUCCESS_THRESHOLD || '1', 10),
+            },
+            autoRestart: {
+                enabled: process.env.METALINK_AUTO_RESTART_ENABLED !== 'false',
+                maxRetries: parseInt(process.env.METALINK_AUTO_RESTART_MAX_RETRIES || '3', 10),
+                baseDelay: parseInt(process.env.METALINK_AUTO_RESTART_BASE_DELAY || '5000', 10),
+                maxDelay: parseInt(process.env.METALINK_AUTO_RESTART_MAX_DELAY || '300000', 10),
+                backoffMultiplier: parseFloat(process.env.METALINK_AUTO_RESTART_BACKOFF_MULTIPLIER || '2'),
+            },
+        };
+        return validateConfig(config);
+    }
+}
+/**
+ * Global config instance (singleton pattern)
+ */
+let globalConfigLoader = null;
+/**
+ * Initialize global config
+ */
+export async function initializeConfig(configPath) {
+    globalConfigLoader = new ConfigLoader(configPath);
+    return globalConfigLoader.load();
+}
+/**
+ * Initialize config synchronously
+ */
+export function initializeConfigSync(configPath) {
+    globalConfigLoader = new ConfigLoader(configPath);
+    return globalConfigLoader.loadSync();
+}
+/**
+ * Get global config instance
+ */
+export function getConfigLoader() {
+    if (!globalConfigLoader) {
+        throw new Error('Config not initialized. Call initializeConfig() first.');
+    }
+    return globalConfigLoader;
+}
+/**
+ * Get global config
+ */
+export function getConfig() {
+    return getConfigLoader().getConfig();
+}
+//# sourceMappingURL=loader.js.map