@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.0

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

@@ -84,8 +84,8 @@ export const listCommand = new Command('list')
                 Name: server.name,
                 // Now need to display server instance information
                 Instances: server.instances?.length || 0,
-                Type: server.config.type,
-                Enabled: server.config.enabled
+                Type: server.config.template.type,
+                Enabled: server.config.instances.some((i) => i.enabled !== false)
             })));
         }
         process.exit(0);

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

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,aAAa,SAYtB,CAAC"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,aAAa,SAYtB,CAAC"}

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

@@ -82,38 +82,49 @@ function printFormattedStatus(status) {
     console.log(`📡 Web UI: ${cyan}${webUiUrl}${reset}`);
     console.log(`🔗 MCP Endpoint: ${cyan}${mcpEndpoint}${reset}`);
     console.log(`📄 PID File: ${dim}${formatPath(status.pidFilePath)}${reset}`);
-    // MCP Servers section
+    // MCP Servers section - split into connected and disconnected
     if (status.mcpServers && status.mcpServers.length > 0) {
-        console.log('');
-        console.log(`${yellow}MCP Servers:${reset}`);
-        console.log(`${dim}═════════════${reset}`);
-        // Calculate column widths
-        let maxNameLen = 'Server Name'.length;
-        let maxTypeLen = 'Type'.length;
-        const maxStatusLen = 'Disconnected'.length;
-        for (const server of status.mcpServers) {
-            maxNameLen = Math.max(maxNameLen, (server.name || '').length);
-            maxTypeLen = Math.max(maxTypeLen, (server.type || '').length);
-        }
-        // Simple table without complex borders
-        const headerName = 'Server Name'.padEnd(maxNameLen);
-        const headerType = 'Type'.padEnd(maxTypeLen);
-        const headerStatus = 'Status'.padEnd(maxStatusLen);
-        console.log(`${cyan}${headerName}  ${headerType}  ${headerStatus}  Tools  Resources${reset}`);
-        console.log(`${dim}${'─'.repeat(maxNameLen + maxTypeLen + maxStatusLen + 20)}${reset}`);
-        for (const server of status.mcpServers) {
-            const name = (server.name || '').padEnd(maxNameLen);
-            const type = (server.type || '').padEnd(maxTypeLen);
-            const statusText = server.connected
-                ? `${green}Connected${reset}`.padEnd(maxStatusLen + 9)
-                : `${red}Disconnected${reset}`.padEnd(maxStatusLen + 9);
-            const tools = server.toolsCount.toString().padStart(5);
-            const resources = server.resourcesCount.toString().padStart(9);
-            console.log(`${name}  ${type}  ${statusText}  ${tools}  ${resources}`);
-            if (server.error) {
-                console.log(`  ${red}Error: ${server.error}${reset}`);
+        const connectedServers = status.mcpServers.filter((s) => s.connected);
+        const disconnectedServers = status.mcpServers.filter((s) => !s.connected);
+        // Function to display a server list
+        const displayServerList = (servers, title, titleColor) => {
+            if (servers.length === 0)
+                return;
+            console.log('');
+            console.log(`${titleColor}${title}${reset}`);
+            console.log(`${dim}${'═'.repeat(title.length)}${reset}`);
+            // Calculate column widths
+            let maxNameLen = 'Server Name'.length;
+            let maxTypeLen = 'Type'.length;
+            const maxStatusLen = 'Disconnected'.length;
+            for (const server of servers) {
+                maxNameLen = Math.max(maxNameLen, (server.name || '').length);
+                maxTypeLen = Math.max(maxTypeLen, (server.type || '').length);
             }
-        }
+            // Simple table without complex borders
+            const headerName = 'Server Name'.padEnd(maxNameLen);
+            const headerType = 'Type'.padEnd(maxTypeLen);
+            const headerStatus = 'Status'.padEnd(maxStatusLen);
+            console.log(`${cyan}${headerName}  ${headerType}  ${headerStatus}  Tools  Resources${reset}`);
+            console.log(`${dim}${'─'.repeat(maxNameLen + maxTypeLen + maxStatusLen + 20)}${reset}`);
+            for (const server of servers) {
+                const name = (server.name || '').padEnd(maxNameLen);
+                const type = (server.type || '').padEnd(maxTypeLen);
+                const statusText = server.connected
+                    ? `${green}Connected${reset}`.padEnd(maxStatusLen + 9)
+                    : `${red}Disconnected${reset}`.padEnd(maxStatusLen + 9);
+                const tools = server.toolsCount.toString().padStart(5);
+                const resources = server.resourcesCount.toString().padStart(9);
+                console.log(`${name}  ${type}  ${statusText}  ${tools}  ${resources}`);
+                if (server.error) {
+                    console.log(`  ${red}Error: ${server.error}${reset}`);
+                }
+            }
+        };
+        // Display connected servers first
+        displayServerList(connectedServers, 'MCP Servers (Connected):', green);
+        // Then display disconnected servers
+        displayServerList(disconnectedServers, 'MCP Servers (Disconnected):', red);
     }
     // MCP Client Configuration
     console.log('');

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAiBnC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/index.ts"],"names":[],"mappings":";AAEA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAiBnC"}

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

@@ -6,6 +6,7 @@
 import { Command } from 'commander';
 import { argv } from 'node:process';
 import { pathToFileURL } from 'node:url';
+import { getAppVersion } from '../utils/version.js';
 import { startCommand } from './commands/start.js';
 import { stopCommand } from './commands/stop.js';
 import { statusCommand } from './commands/status.js';
@@ -71,7 +72,7 @@ export function createCli() {
     program
         .name('mcp-hub-lite')
         .description('Lightweight MCP Gateway for managing MCP servers')
-        .version('1.0.0');
+        .version(process.env.npm_package_version ?? getAppVersion(), '-v, --version');
     // Register all core commands
     program.addCommand(startCommand);
     program.addCommand(stopCommand);

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

@@ -159,10 +159,19 @@ export declare function restartServer(options: ServerOptions): Promise<void>;
 export declare function listServers(): Promise<{
     instances: {
         id: string;
-        timestamp: number;
-        hash: string;
+        enabled: boolean;
+        args: string[];
+        env: Record<string, string>;
+        headers: Record<string, string>;
+        tags: Record<string, string>;
+        index?: number | undefined;
+        displayName?: string | undefined;
+        timestamp?: number | undefined;
         pid?: number | undefined;
         startTime?: number | undefined;
+        proxy?: {
+            url: string;
+        } | undefined;
     }[];
     name: string;
     config: import("../config/config-manager.js").ServerConfig;

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

@@ -1 +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"}
+{"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/config/config-change-logger.d.ts

@@ -3,6 +3,28 @@
  * Handles comparison and logging of configuration changes.
  */
 import type { SystemConfig } from './config.schema.js';
+/**
+ * Gets the changes between two objects.
+ *
+ * This function performs a deep comparison of two objects
+ * and returns all changes at the field level.
+ *
+ * @param oldObj - The original object
+ * @param newObj - The new object
+ * @returns An array of change strings
+ */
+export declare function getObjectChanges(oldObj: unknown, newObj: unknown): string[];
+/**
+ * Logs object changes with a custom title.
+ *
+ * @param title - The title to display before the changes
+ * @param oldObj - The original object
+ * @param newObj - The new object
+ * @param logModule - The log module to use
+ */
+export declare function logObjectChangesWithTitle(title: string, oldObj: unknown, newObj: unknown, logModule?: {
+    module: string;
+}): void;
 /**
  * Logs the differences between two system configurations.
  *

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

@@ -1 +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"}
+{"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;AAgGvD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,CAwC3E;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,OAAO,EACf,SAAS,GAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAA+B,GACzD,IAAI,CAON;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,GAAG,IAAI,CAOvF"}

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

@@ -4,15 +4,102 @@
  */
 import { logger, LOG_MODULES } from '../utils/logger.js';
 /**
- * Logs the differences between two system configurations.
+ * Sensitive KEY patterns (case-insensitive).
+ * Fields whose key contains any of these patterns will have their values masked.
+ */
+const SENSITIVE_KEY_PATTERNS = [
+    'token',
+    'key',
+    'authorization',
+    'secret',
+    'password',
+    'credential'
+];
+/**
+ * Sensitive VALUE patterns.
+ * String values containing any of these patterns will be masked.
+ */
+const SENSITIVE_VALUE_PATTERNS = ['Bearer', 'sk-', 'sk_', 'api_key', 'apikey'];
+/**
+ * Checks if a key looks sensitive based on its name.
  *
- * This function performs a deep comparison of two configuration objects
- * and logs all changes at the field level for audit purposes.
+ * @param key - The key to check
+ * @returns True if the key is sensitive
+ */
+function isSensitiveKey(key) {
+    const lowerKey = key.toLowerCase();
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => lowerKey.includes(pattern));
+}
+/**
+ * Checks if a value looks sensitive based on its content.
  *
- * @param oldConfig - The original configuration
- * @param newConfig - The new configuration
+ * @param value - The value to check
+ * @returns True if the value is sensitive
  */
-export function logConfigChanges(oldConfig, newConfig) {
+function isSensitiveValue(value) {
+    return SENSITIVE_VALUE_PATTERNS.some((pattern) => value.includes(pattern));
+}
+/**
+ * Masks a sensitive value while preserving partial visibility.
+ * - For values with length < 8: preserves first and last character
+ * - For values with length >= 8: preserves first 4 and last 4 characters
+ *
+ * @param value - The value to mask
+ * @returns The masked value
+ */
+function maskSensitiveValue(value) {
+    if (value.length < 8) {
+        return value[0] + '****' + value[value.length - 1];
+    }
+    return value.substring(0, 4) + '********' + value.substring(value.length - 4);
+}
+/**
+ * Normalizes a URL string by removing trailing slashes.
+ *
+ * @param url - The URL to normalize
+ * @returns Normalized URL
+ */
+function normalizeUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+/**
+ * Checks if a path looks like a URL field.
+ *
+ * @param path - The field path to check
+ * @returns True if the path looks like a URL field
+ */
+function isUrlField(path) {
+    const urlPatterns = [/\.url$/, /^url$/, /\.proxy\.url$/];
+    return urlPatterns.some((pattern) => pattern.test(path));
+}
+/**
+ * Compares two values with URL normalization support.
+ *
+ * @param val1 - First value
+ * @param val2 - Second value
+ * @param path - The field path for context
+ * @returns True if values are considered equal
+ */
+function areValuesEqual(val1, val2, path) {
+    // Special handling for URL fields
+    if (isUrlField(path)) {
+        if (typeof val1 === 'string' && typeof val2 === 'string') {
+            return normalizeUrl(val1) === normalizeUrl(val2);
+        }
+    }
+    return JSON.stringify(val1) === JSON.stringify(val2);
+}
+/**
+ * Gets the changes between two objects.
+ *
+ * This function performs a deep comparison of two objects
+ * and returns all changes at the field level.
+ *
+ * @param oldObj - The original object
+ * @param newObj - The new object
+ * @returns An array of change strings
+ */
+export function getObjectChanges(oldObj, newObj) {
     const changes = [];
     const compare = (obj1, obj2, path) => {
         const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
@@ -20,7 +107,7 @@ export function logConfigChanges(oldConfig, newConfig) {
             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))
+            if (areValuesEqual(val1, val2, currentPath))
                 continue;
             if (typeof val1 === 'object' &&
                 val1 !== null &&
@@ -31,13 +118,50 @@ export function logConfigChanges(oldConfig, newConfig) {
                 compare(val1, val2, currentPath);
             }
             else {
-                const formatVal = (v) => (v === undefined ? 'undefined' : JSON.stringify(v));
-                changes.push(`${currentPath} = ${formatVal(val1)} -> ${formatVal(val2)}`);
+                const formatVal = (key, v) => {
+                    if (v === undefined)
+                        return 'undefined';
+                    const str = JSON.stringify(v);
+                    if (typeof v === 'string' && (isSensitiveKey(key) || isSensitiveValue(v))) {
+                        return `"${maskSensitiveValue(v)}"`;
+                    }
+                    return str;
+                };
+                changes.push(`${currentPath} = ${formatVal(key, val1)} -> ${formatVal(key, val2)}`);
             }
         }
     };
-    compare(oldConfig, newConfig, '');
+    compare(oldObj, newObj, '');
+    return changes;
+}
+/**
+ * Logs object changes with a custom title.
+ *
+ * @param title - The title to display before the changes
+ * @param oldObj - The original object
+ * @param newObj - The new object
+ * @param logModule - The log module to use
+ */
+export function logObjectChangesWithTitle(title, oldObj, newObj, logModule = LOG_MODULES.CONFIG_CHANGES) {
+    const changes = getObjectChanges(oldObj, newObj);
+    if (changes.length > 0) {
+        const message = `${title}\n${changes.join('\n')}`;
+        logger.info(message, logModule);
+    }
+}
+/**
+ * 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 = getObjectChanges(oldConfig, newConfig);
     if (changes.length > 0) {
-        logger.info(`${changes.join('\n')}`, LOG_MODULES.CONFIG_CHANGES);
+        const message = `System Config Changes：\n${changes.join('\n')}`;
+        logger.info(message, LOG_MODULES.CONFIG_CHANGES);
     }
 }

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

@@ -1,6 +1,7 @@
 /**
- * Configuration loading utilities.
+ * Configuration loading utilities (v1.1 only).
  * Handles loading and parsing configuration from files with validation.
+ * Supports automatic migration from v1.0 to v1.1.
  */
 import type { SystemConfig } from './config.schema.js';
 /**
@@ -9,14 +10,14 @@ import type { SystemConfig } from './config.schema.js';
  * This function handles the complete configuration loading process:
  * - Checks if the config file exists at the specified path
  * - Reads and parses the JSON configuration
+ * - Detects legacy v1.0 configuration and auto-migrates to v1.1
  * - 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
+ * @param autoMigrate - Whether to automatically migrate v1.0 to v1.1 (default: true)
+ * @returns The loaded and validated system configuration (v1.1 format)
  */
-export declare function loadConfig(configPath: string): SystemConfig;
+export declare function loadConfig(configPath: string, autoMigrate?: boolean): SystemConfig;
 //# sourceMappingURL=config-loader.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../../../src/config/config-loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,GAAE,OAAc,GAAG,YAAY,CAoGxF"}

package/dist/server/src/config/config-loader.js

@@ -1,66 +1,104 @@
 /**
- * Configuration loading utilities.
+ * Configuration loading utilities (v1.1 only).
  * Handles loading and parsing configuration from files with validation.
+ * Supports automatic migration from v1.0 to v1.1.
  */
 import * as fs from 'fs';
 import { logger, LOG_MODULES } from '../utils/logger.js';
-import { SystemConfigSchema } from './config.schema.js';
+import { SystemConfigSchema, isLegacyV1Config } from './config.schema.js';
+import { migrateConfig } from './config-migrator.js';
 import { convertHttpToStreamableHttp } from './type-converter.js';
+import { reassignServerInstanceIndexes } from './server-config-manager.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
+ * - Detects legacy v1.0 configuration and auto-migrates to v1.1
  * - 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
+ * @param autoMigrate - Whether to automatically migrate v1.0 to v1.1 (default: true)
+ * @returns The loaded and validated system configuration (v1.1 format)
  */
-export function loadConfig(configPath) {
+export function loadConfig(configPath, autoMigrate = true) {
     try {
         if (fs.existsSync(configPath)) {
             logger.info(`Loading configuration from: ${configPath}`, LOG_MODULES.CONFIG_MANAGER);
             const content = fs.readFileSync(configPath, 'utf-8');
             let config = JSON.parse(content);
+            // Check if automatic migration is enabled and config is legacy v1.0
+            if (autoMigrate && isLegacyV1Config(config)) {
+                logger.info('Detected legacy v1.0 configuration, starting automatic migration to v1.1', LOG_MODULES.CONFIG_MANAGER);
+                const migrationResult = migrateConfig(configPath, {
+                    dryRun: false,
+                    createBackup: true,
+                    validateAfterMigration: true
+                });
+                if (migrationResult.success && migrationResult.migratedConfig) {
+                    logger.info('Configuration successfully migrated to v1.1', LOG_MODULES.CONFIG_MANAGER);
+                    if (migrationResult.backupPath) {
+                        logger.info(`Backup created at: ${migrationResult.backupPath}`, LOG_MODULES.CONFIG_MANAGER);
+                    }
+                    config = migrationResult.migratedConfig;
+                }
+                else {
+                    logger.warn(`Migration failed, continuing with default config: ${migrationResult.error}`, LOG_MODULES.CONFIG_MANAGER);
+                    return SystemConfigSchema.parse({});
+                }
+            }
             // Unified type conversion: convert http to streamable-http
             config = convertHttpToStreamableHttp(config);
-            // Ensure defaults without validation errors blocking
+            // Handle backward compatibility for instanceSelectionStrategy in root level
+            if (config.servers) {
+                for (const [serverName, serverConfig] of Object.entries(config.servers)) {
+                    if (serverConfig &&
+                        typeof serverConfig === 'object' &&
+                        'instanceSelectionStrategy' in serverConfig &&
+                        serverConfig.instanceSelectionStrategy !== undefined) {
+                        const legacyConfig = serverConfig;
+                        const strategy = legacyConfig.instanceSelectionStrategy;
+                        if (typeof strategy === 'string') {
+                            legacyConfig.template.instanceSelectionStrategy = strategy;
+                        }
+                        delete legacyConfig.instanceSelectionStrategy;
+                        logger.debug(`Migrated instanceSelectionStrategy for server ${serverName} to template`, LOG_MODULES.CONFIG_LOADER);
+                    }
+                }
+            }
+            // Validate and return configuration
             try {
-                // Use safeParse to validate configuration
                 const parsed = SystemConfigSchema.safeParse(config);
                 if (parsed.success) {
-                    // Ensure server configurations are sorted by name
                     const configWithSortedServers = {
                         ...parsed.data,
                         servers: Object.fromEntries(Object.entries(parsed.data.servers).sort(([a], [b]) => a.localeCompare(b)))
                     };
+                    // Ensure all server instances have proper indexes
+                    for (const serverName of Object.keys(configWithSortedServers.servers)) {
+                        reassignServerInstanceIndexes(serverName, configWithSortedServers.servers);
+                    }
                     return configWithSortedServers;
                 }
                 else {
-                    // On validation failure, log error and use default configuration
-                    logger.error(`Config validation failed: ${parsed.error}`);
+                    logger.error(`Config validation failed: ${parsed.error}`, LOG_MODULES.CONFIG_LOADER);
                     return SystemConfigSchema.parse({});
                 }
             }
             catch (e) {
-                logger.error(`Failed to parse config: ${e}`);
-                // On parsing failure, use default configuration
+                logger.error(`Failed to parse config: ${e}`, LOG_MODULES.CONFIG_LOADER);
                 return SystemConfigSchema.parse({});
             }
         }
         else {
-            // When config file doesn't exist, create default config in memory only
             return SystemConfigSchema.parse({});
         }
     }
     catch (error) {
-        logger.error(`Failed to load config: ${error}`);
-        // On config file load failure, use default configuration
+        logger.error(`Failed to load config: ${error}`, LOG_MODULES.CONFIG_LOADER);
         return SystemConfigSchema.parse({});
     }
 }