@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/cli/parse-args.js

@@ -0,0 +1,131 @@
+/**
+ * CLI argument parsing utility
+ * Provides parameter validation and parsing functions
+ */
+/**
+ * Parses and validates a port number from a string input.
+ *
+ * This function converts a string representation of a port number to an integer
+ * and validates that it falls within the valid TCP/UDP port range (1-65535).
+ * It is primarily used for CLI argument parsing when users specify custom ports
+ * via command line options like `--port` or `-p`.
+ *
+ * @param value - The string representation of the port number to parse
+ * @returns The validated port number as an integer
+ * @throws {Error} If the input is not a valid number or outside the valid port range (1-65535)
+ *
+ * @example
+ * ```typescript
+ * const port = parsePort("8080"); // Returns 8080
+ * const invalidPort = parsePort("99999"); // Throws Error: Invalid port: 99999. Must be between 1 and 65535.
+ * ```
+ */
+export function parsePort(value) {
+    const port = parseInt(value, 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port: ${value}. Must be between 1 and 65535.`);
+    }
+    return port;
+}
+/**
+ * Parses and validates a hostname or IP address from a string input.
+ *
+ * This function performs basic validation on hostname/IP address inputs by ensuring
+ * the value is not empty or whitespace-only. It trims any leading/trailing whitespace
+ * from the input and returns the cleaned hostname. This function is used when parsing
+ * CLI arguments for host configuration via options like `--host` or `-h`.
+ *
+ * Note: This function performs only basic validation (non-empty check). More complex
+ * hostname format validation (e.g., DNS compliance, IP address format) should be
+ * handled at the network layer or by the underlying server implementation.
+ *
+ * @param value - The hostname or IP address string to parse and validate
+ * @returns The trimmed hostname/IP address string
+ * @throws {Error} If the input is null, undefined, or contains only whitespace
+ *
+ * @example
+ * ```typescript
+ * const host = parseHost("localhost"); // Returns "localhost"
+ * const hostWithSpaces = parseHost("  127.0.0.1  "); // Returns "127.0.0.1"
+ * const emptyHost = parseHost(""); // Throws Error: Host cannot be empty
+ * ```
+ */
+export function parseHost(value) {
+    // Simple hostname format validation
+    if (!value || value.trim().length === 0) {
+        throw new Error('Host cannot be empty');
+    }
+    return value.trim();
+}
+/**
+ * Validates a configuration file path to ensure it points to a valid JSON file.
+ *
+ * This function checks that the provided file path ends with the `.json` extension,
+ * ensuring that only JSON configuration files are accepted. It is used during CLI
+ * argument parsing when users specify custom configuration files via the `--config`
+ * option. The function does not verify file existence or accessibility, as those
+ * checks should be performed by the file system operations that actually read the file.
+ *
+ * @param path - The file path to validate as a configuration file path
+ * @returns The original path string if validation passes
+ * @throws {Error} If the path does not end with the '.json' extension
+ *
+ * @example
+ * ```typescript
+ * const validPath = validateConfigPath("./config.json"); // Returns "./config.json"
+ * const invalidPath = validateConfigPath("./config.txt"); // Throws Error: Config file must be a .json file
+ * ```
+ */
+export function validateConfigPath(path) {
+    if (!path.endsWith('.json')) {
+        throw new Error('Config file must be a .json file');
+    }
+    return path;
+}
+/**
+ * Validate log level
+ */
+export function validateLogLevel(level) {
+    const validLevels = ['error', 'warn', 'info', 'debug'];
+    const lowerLevel = level.toLowerCase();
+    if (!validLevels.includes(lowerLevel)) {
+        throw new Error(`Invalid log level: ${level}. Must be one of: ${validLevels.join(', ')}`);
+    }
+    return lowerLevel;
+}
+/**
+ * Merges CLI options with default values to create a complete configuration object.
+ *
+ * This function takes partial CLI options (which may contain only some of the available
+ * options) and merges them with a complete set of default values. It uses nullish coalescing
+ * (??) to ensure that only undefined or null values are replaced with defaults, preserving
+ * explicitly set falsy values like `false` for boolean options.
+ *
+ * The function handles all standard CLI options including:
+ * - port: TCP port number for the server
+ * - host: Hostname or IP address to bind to
+ * - config: Path to configuration file
+ * - foreground: Whether to run in foreground mode
+ * - stdio: Whether to use stdio transport mode
+ *
+ * @param options - Partial CLI options object containing user-specified values
+ * @param defaults - Complete CLI options object containing default values
+ * @returns {CliOptions} A complete CLI options object with merged values
+ *
+ * @example
+ * ```typescript
+ * const userOptions = { port: 8080 };
+ * const defaultOptions = { port: 7788, host: 'localhost', config: '.mcp-hub.json', foreground: false, stdio: false };
+ * const merged = mergeOptions(userOptions, defaultOptions);
+ * // Result: { port: 8080, host: 'localhost', config: '.mcp-hub.json', foreground: false, stdio: false }
+ * ```
+ */
+export function mergeOptions(options, defaults) {
+    return {
+        port: options.port ?? defaults.port,
+        host: options.host ?? defaults.host,
+        config: options.config ?? defaults.config,
+        foreground: options.foreground ?? defaults.foreground,
+        stdio: options.stdio ?? defaults.stdio
+    };
+}

package/dist/server/src/cli/server.d.ts

@@ -0,0 +1,171 @@
+/**
+ * CLI Server Management Functions
+ * Handles start, stop, status, restart operations
+ */
+interface ServerOptions {
+    port: number;
+    host: string;
+    configPath?: string;
+}
+interface McpServerStatus {
+    name: string;
+    type: string;
+    connected: boolean;
+    toolsCount: number;
+    resourcesCount: number;
+    error?: string;
+}
+export interface EnhancedServerStatus {
+    running: boolean;
+    pid?: string;
+    host: string;
+    port: number;
+    message?: string;
+    pidFilePath: string;
+    mcpServers?: McpServerStatus[];
+}
+/**
+ * Starts the MCP Hub Lite server with the specified configuration options.
+ *
+ * This function initializes and starts the full MCP Hub Lite server, including:
+ * - Fastify HTTP server with web interface and API
+ * - Automatic connection to enabled MCP servers
+ * - Port conflict detection
+ * - Graceful shutdown handlers
+ * - PID file management
+ *
+ * After successful startup, the process ID is written to a PID file for
+ * process management and monitoring purposes.
+ *
+ * Note: The `configPath` option is accepted for API consistency but is not
+ * currently used by this function. Configuration loading is handled by the
+ * ConfigManager singleton during module initialization.
+ *
+ * @param {ServerOptions} options - Configuration options for server startup
+ * @param {number} options.port - The port number to listen on (e.g., 7788)
+ * @param {string} options.host - The host address to bind to (e.g., 'localhost', '0.0.0.0')
+ * @param {string} [options.configPath] - Optional path to custom configuration file (currently unused)
+ * @returns {Promise<void>} A promise that resolves when the server is successfully started
+ * @throws {Error} If the server fails to start due to port conflicts, permission issues, or configuration errors
+ *
+ * @example
+ * ```typescript
+ * await startServer({
+ *   port: 7788,
+ *   host: 'localhost'
+ * });
+ * console.log(`Server running on http://localhost:7788`);
+ * ```
+ *
+ * @see {@link runServer} for the full server startup implementation
+ * @see {@link PidManager} for process ID management
+ */
+export declare function startServer(options: ServerOptions): Promise<void>;
+/**
+ * Stops the MCP Hub Lite server gracefully by sending a termination signal.
+ *
+ * This function terminates the running server process by:
+ * - Reading the PID from the PID file (or using provided PID)
+ * - Sending SIGTERM signal to gracefully terminate the process
+ * - Cleaning up the PID file to prevent stale process detection
+ *
+ * If no PID is provided, it reads from the PID file managed by PidManager.
+ * If the PID file doesn't exist or the process is already terminated,
+ * the function handles this gracefully without throwing errors.
+ *
+ * @param pid - Optional specific process ID to stop. If not provided, uses PID from PID file.
+ * @returns {Promise<void>} Resolves when the stop operation completes (regardless of success/failure)
+ *
+ * @example
+ * ```typescript
+ * // Stop the currently running server
+ * await stopServer();
+ *
+ * // Stop a specific process ID
+ * await stopServer('12345');
+ * ```
+ */
+export declare function stopServer(pid?: string): Promise<void>;
+/**
+ * Retrieves the current status of the MCP Hub Lite server.
+ *
+ * This function checks if the server is running by:
+ * - Reading the PID from the PID file (or using provided PID)
+ * - Verifying if the process with that PID is still active
+ * - If running, attempts to fetch additional runtime status via HTTP API
+ * - Returns enhanced status with configuration and runtime information
+ *
+ * The function uses `process.kill(pid, 0)` which doesn't actually kill the process
+ * but checks if a process with the given PID exists and is accessible.
+ *
+ * @param pid - Optional specific process ID to check. If not provided, uses PID from PID file.
+ * @returns {Promise<EnhancedServerStatus>} Enhanced status object with full details
+ *
+ * @example
+ * ```typescript
+ * const status = await getServerStatus();
+ * if (status.running) {
+ *   console.log(`Server running on ${status.host}:${status.port} with PID ${status.pid}`);
+ * }
+ * ```
+ */
+export declare function getServerStatus(pid?: string): Promise<EnhancedServerStatus>;
+/**
+ * Restarts the MCP Hub Lite server with the same configuration options.
+ *
+ * This function performs a graceful restart by:
+ * - First stopping the currently running server (if any)
+ * - Then starting a new server instance with the provided options
+ *
+ * This is useful for applying configuration changes or recovering from
+ * transient issues without manual intervention.
+ *
+ * @param options - Configuration options for the new server instance
+ * @param {number} options.port - The port number to listen on
+ * @param {string} options.host - The host address to bind to
+ * @param {string} [options.configPath] - Optional path to custom configuration file
+ * @returns {Promise<void>} A promise that resolves when the server is successfully restarted
+ *
+ * @example
+ * ```typescript
+ * await restartServer({
+ *   port: 7788,
+ *   host: 'localhost'
+ * });
+ * ```
+ */
+export declare function restartServer(options: ServerOptions): Promise<void>;
+/**
+ * Lists all configured MCP servers with their instances.
+ *
+ * This function retrieves all servers managed by the HubManager and
+ * enriches them with their associated instances (if any). Each server
+ * object includes its configuration and an array of active instances.
+ *
+ * This is primarily used by the CLI `list` command to display the
+ * current server configuration to users.
+ *
+ * @returns {Promise<Array>} Array of server objects with instances included
+ *
+ * @example
+ * ```typescript
+ * const servers = await listServers();
+ * servers.forEach(server => {
+ *   console.log(`Server: ${server.name}`);
+ *   console.log(`Instances: ${server.instances.length}`);
+ * });
+ * ```
+ */
+export declare function listServers(): Promise<{
+    instances: {
+        id: string;
+        timestamp: number;
+        hash: string;
+        pid?: number | undefined;
+        startTime?: number | undefined;
+    }[];
+    name: string;
+    config: import("../config/config-manager.js").ServerConfig;
+}[]>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server/src/cli/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/cli/server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAMvE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,iBAO5C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,eAAe,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0CjF;AAgED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAGzE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW;;;;;;;;;;KAUhC"}

package/dist/server/src/cli/server.js

@@ -0,0 +1,246 @@
+/**
+ * CLI Server Management Functions
+ * Handles start, stop, status, restart operations
+ */
+import { PidManager } from '../pid/manager.js';
+import { getConfigManager } from '../config/config-manager.js';
+import { getPidFilePath } from '../pid/file.js';
+import { runServer } from '../server/runner.js';
+/**
+ * Starts the MCP Hub Lite server with the specified configuration options.
+ *
+ * This function initializes and starts the full MCP Hub Lite server, including:
+ * - Fastify HTTP server with web interface and API
+ * - Automatic connection to enabled MCP servers
+ * - Port conflict detection
+ * - Graceful shutdown handlers
+ * - PID file management
+ *
+ * After successful startup, the process ID is written to a PID file for
+ * process management and monitoring purposes.
+ *
+ * Note: The `configPath` option is accepted for API consistency but is not
+ * currently used by this function. Configuration loading is handled by the
+ * ConfigManager singleton during module initialization.
+ *
+ * @param {ServerOptions} options - Configuration options for server startup
+ * @param {number} options.port - The port number to listen on (e.g., 7788)
+ * @param {string} options.host - The host address to bind to (e.g., 'localhost', '0.0.0.0')
+ * @param {string} [options.configPath] - Optional path to custom configuration file (currently unused)
+ * @returns {Promise<void>} A promise that resolves when the server is successfully started
+ * @throws {Error} If the server fails to start due to port conflicts, permission issues, or configuration errors
+ *
+ * @example
+ * ```typescript
+ * await startServer({
+ *   port: 7788,
+ *   host: 'localhost'
+ * });
+ * console.log(`Server running on http://localhost:7788`);
+ * ```
+ *
+ * @see {@link runServer} for the full server startup implementation
+ * @see {@link PidManager} for process ID management
+ */
+export async function startServer(options) {
+    // Use the full runServer implementation which includes auto-connection of MCP servers
+    await runServer({
+        port: options.port,
+        host: options.host
+    });
+}
+/**
+ * Stops the MCP Hub Lite server gracefully by sending a termination signal.
+ *
+ * This function terminates the running server process by:
+ * - Reading the PID from the PID file (or using provided PID)
+ * - Sending SIGTERM signal to gracefully terminate the process
+ * - Cleaning up the PID file to prevent stale process detection
+ *
+ * If no PID is provided, it reads from the PID file managed by PidManager.
+ * If the PID file doesn't exist or the process is already terminated,
+ * the function handles this gracefully without throwing errors.
+ *
+ * @param pid - Optional specific process ID to stop. If not provided, uses PID from PID file.
+ * @returns {Promise<void>} Resolves when the stop operation completes (regardless of success/failure)
+ *
+ * @example
+ * ```typescript
+ * // Stop the currently running server
+ * await stopServer();
+ *
+ * // Stop a specific process ID
+ * await stopServer('12345');
+ * ```
+ */
+export async function stopServer(pid) {
+    const actualPid = pid || PidManager.getPid()?.toString();
+    if (actualPid) {
+        process.kill(parseInt(actualPid), 'SIGTERM');
+        PidManager.removePid();
+    }
+}
+/**
+ * Retrieves the current status of the MCP Hub Lite server.
+ *
+ * This function checks if the server is running by:
+ * - Reading the PID from the PID file (or using provided PID)
+ * - Verifying if the process with that PID is still active
+ * - If running, attempts to fetch additional runtime status via HTTP API
+ * - Returns enhanced status with configuration and runtime information
+ *
+ * The function uses `process.kill(pid, 0)` which doesn't actually kill the process
+ * but checks if a process with the given PID exists and is accessible.
+ *
+ * @param pid - Optional specific process ID to check. If not provided, uses PID from PID file.
+ * @returns {Promise<EnhancedServerStatus>} Enhanced status object with full details
+ *
+ * @example
+ * ```typescript
+ * const status = await getServerStatus();
+ * if (status.running) {
+ *   console.log(`Server running on ${status.host}:${status.port} with PID ${status.pid}`);
+ * }
+ * ```
+ */
+export async function getServerStatus(pid) {
+    const configManager = getConfigManager();
+    const config = configManager.getConfig();
+    const host = process.env.HOST || config.system.host;
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : config.system.port;
+    const pidFilePath = getPidFilePath();
+    const actualPid = pid || PidManager.getPid()?.toString();
+    if (!actualPid) {
+        return {
+            running: false,
+            host,
+            port,
+            pidFilePath,
+            message: 'Server not running'
+        };
+    }
+    try {
+        process.kill(parseInt(actualPid), 0); // Signal 0 just checks if process exists
+        // Try to fetch runtime status via HTTP API
+        const mcpServers = await fetchRuntimeStatus(host, port);
+        return {
+            running: true,
+            pid: actualPid,
+            host,
+            port,
+            pidFilePath,
+            mcpServers
+        };
+    }
+    catch {
+        return {
+            running: false,
+            host,
+            port,
+            pidFilePath,
+            message: 'Server process not found'
+        };
+    }
+}
+/**
+ * Fetches runtime status from the running server via HTTP API.
+ *
+ * This function attempts to connect to the local server API to retrieve
+ * real-time status information about connected MCP servers. It uses a
+ * short timeout to ensure the status command remains responsive even
+ * if the server is unresponsive.
+ *
+ * @param host - The host address to connect to
+ * @param port - The port number to connect to
+ * @returns Promise with array of MCP server status, or undefined if API call fails
+ */
+async function fetchRuntimeStatus(host, port) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 500);
+        const response = await fetch(`http://${host}:${port}/web/mcp/status`, {
+            signal: controller.signal,
+            headers: {
+                Accept: 'application/json'
+            }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return undefined;
+        }
+        const statusData = (await response.json());
+        // Map status data directly (API now includes name and type)
+        const result = statusData.map((item) => ({
+            name: item.name,
+            type: item.type,
+            connected: item.status.connected,
+            toolsCount: item.status.toolsCount,
+            resourcesCount: item.status.resourcesCount,
+            error: item.status.error
+        }));
+        return result;
+    }
+    catch {
+        // Silent failure - API not available, just return undefined
+        return undefined;
+    }
+}
+/**
+ * Restarts the MCP Hub Lite server with the same configuration options.
+ *
+ * This function performs a graceful restart by:
+ * - First stopping the currently running server (if any)
+ * - Then starting a new server instance with the provided options
+ *
+ * This is useful for applying configuration changes or recovering from
+ * transient issues without manual intervention.
+ *
+ * @param options - Configuration options for the new server instance
+ * @param {number} options.port - The port number to listen on
+ * @param {string} options.host - The host address to bind to
+ * @param {string} [options.configPath] - Optional path to custom configuration file
+ * @returns {Promise<void>} A promise that resolves when the server is successfully restarted
+ *
+ * @example
+ * ```typescript
+ * await restartServer({
+ *   port: 7788,
+ *   host: 'localhost'
+ * });
+ * ```
+ */
+export async function restartServer(options) {
+    await stopServer();
+    await startServer(options);
+}
+/**
+ * Lists all configured MCP servers with their instances.
+ *
+ * This function retrieves all servers managed by the HubManager and
+ * enriches them with their associated instances (if any). Each server
+ * object includes its configuration and an array of active instances.
+ *
+ * This is primarily used by the CLI `list` command to display the
+ * current server configuration to users.
+ *
+ * @returns {Promise<Array>} Array of server objects with instances included
+ *
+ * @example
+ * ```typescript
+ * const servers = await listServers();
+ * servers.forEach(server => {
+ *   console.log(`Server: ${server.name}`);
+ *   console.log(`Instances: ${server.instances.length}`);
+ * });
+ * ```
+ */
+export async function listServers() {
+    // Dynamic import to avoid loading heavyweight services for simple commands
+    const { hubManager } = await import('../services/hub-manager.service.js');
+    const servers = hubManager.getAllServers();
+    const serverInstances = hubManager.getServerInstances();
+    return servers.map((server) => ({
+        ...server,
+        instances: serverInstances[server.name] || []
+    }));
+}

package/dist/server/src/config/config-change-logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Configuration change logging utilities.
+ * Handles comparison and logging of configuration changes.
+ */
+import type { SystemConfig } from './config.schema.js';
+/**
+ * Logs the differences between two system configurations.
+ *
+ * This function performs a deep comparison of two configuration objects
+ * and logs all changes at the field level for audit purposes.
+ *
+ * @param oldConfig - The original configuration
+ * @param newConfig - The new configuration
+ */
+export declare function logConfigChanges(oldConfig: SystemConfig, newConfig: SystemConfig): void;
+//# sourceMappingURL=config-change-logger.d.ts.map

package/dist/server/src/config/config-change-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-change-logger.d.ts","sourceRoot":"","sources":["../../../../src/config/config-change-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,GAAG,IAAI,CAoCvF"}

package/dist/server/src/config/config-change-logger.js

@@ -0,0 +1,43 @@
+/**
+ * Configuration change logging utilities.
+ * Handles comparison and logging of configuration changes.
+ */
+import { logger, LOG_MODULES } from '../utils/logger.js';
+/**
+ * Logs the differences between two system configurations.
+ *
+ * This function performs a deep comparison of two configuration objects
+ * and logs all changes at the field level for audit purposes.
+ *
+ * @param oldConfig - The original configuration
+ * @param newConfig - The new configuration
+ */
+export function logConfigChanges(oldConfig, newConfig) {
+    const changes = [];
+    const compare = (obj1, obj2, path) => {
+        const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+        for (const key of allKeys) {
+            const currentPath = path ? `${path}.${key}` : key;
+            const val1 = obj1 && typeof obj1 === 'object' ? obj1[key] : undefined;
+            const val2 = obj2 && typeof obj2 === 'object' ? obj2[key] : undefined;
+            if (JSON.stringify(val1) === JSON.stringify(val2))
+                continue;
+            if (typeof val1 === 'object' &&
+                val1 !== null &&
+                typeof val2 === 'object' &&
+                val2 !== null &&
+                !Array.isArray(val1) &&
+                !Array.isArray(val2)) {
+                compare(val1, val2, currentPath);
+            }
+            else {
+                const formatVal = (v) => (v === undefined ? 'undefined' : JSON.stringify(v));
+                changes.push(`${currentPath} = ${formatVal(val1)} -> ${formatVal(val2)}`);
+            }
+        }
+    };
+    compare(oldConfig, newConfig, '');
+    if (changes.length > 0) {
+        logger.info(`${changes.join('\n')}`, LOG_MODULES.CONFIG_CHANGES);
+    }
+}

package/dist/server/src/config/config-loader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Configuration loading utilities.
+ * Handles loading and parsing configuration from files with validation.
+ */
+import type { SystemConfig } from './config.schema.js';
+/**
+ * Loads configuration from the specified file path.
+ *
+ * This function handles the complete configuration loading process:
+ * - Checks if the config file exists at the specified path
+ * - Reads and parses the JSON configuration
+ * - Performs type conversion for compatibility (e.g., 'http' to 'streamable-http')
+ * - Validates the configuration using Zod schema
+ * - Handles validation failures gracefully by falling back to default configuration
+ *
+ * If the config file doesn't exist or fails to load, a default configuration is returned.
+ *
+ * @param configPath - Path to the configuration file
+ * @returns The loaded and validated system configuration
+ */
+export declare function loadConfig(configPath: string): SystemConfig;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/server/src/config/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../../../src/config/config-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CA0C3D"}