@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

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/server.d.ts

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+/**
+ * CLI command for dynamic MCP server tool operations via API.
+ *
+ * This command provides a simplified CLI interface for interacting with MCP server tools,
+ * supporting four actions: list-servers, list-tools, get-tool, and call-tool. It wraps
+ * the HTTP API endpoints and requires the MCP Hub Lite server to be running.
+ *
+ * ## Command Format
+ *
+ * ```
+ * npm run server <serverName> <action> [toolName] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * ## Supported Actions
+ *
+ * - `list-servers` - List all connected MCP servers
+ * - `list-tools` - List all tools from the specified server
+ * - `get-tool <toolName>` - Get complete schema for a specific tool
+ * - `call-tool <toolName>` - Call a tool on the specified server
+ *
+ * ## Options
+ *
+ * - `--args <json>` - JSON string of tool arguments (for call-tool action)
+ * - `--tags <json>` - JSON object of instance selection tags (call-tool only, for multi-instance servers)
+ *
+ * ## Usage Examples
+ *
+ * ```bash
+ * # List all connected servers
+ * npm run server mcp-hub-lite list-servers
+ *
+ * # List all tools from a specific server
+ * npm run server mcp-hub-lite list-tools
+ *
+ * # Get tool schema
+ * npm run server mcp-hub-lite get-tool list_tools
+ *
+ * # Call a tool with arguments
+ * npm run server mcp-hub-lite call-tool list_tools --args '{"serverName":"mcp-hub-lite"}'
+ *
+ * # Call a tool with tags for multi-instance selection
+ * npm run server baidu-search call-tool search --args '{"query":"天气"}' --tags '{"env":"prod"}'
+ * ```
+ *
+ * ## Error Handling
+ *
+ * - Exits with code 1 if the server is not running
+ * - Exits with code 1 if action is unknown
+ * - Exits with code 1 if toolName is required but not provided
+ * - Exits with code 1 if JSON parsing fails for --args or --tags
+ * - Exits with code 1 if the underlying API call fails
+ *
+ * @returns {Command} The configured server command instance for registration with Commander.js
+ */
+export declare const serverCommand: Command;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,aAAa,SAkItB,CAAC"}

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

@@ -0,0 +1,169 @@
+import { Command } from 'commander';
+import { getServerStatus } from '../server.js';
+/**
+ * CLI command for dynamic MCP server tool operations via API.
+ *
+ * This command provides a simplified CLI interface for interacting with MCP server tools,
+ * supporting four actions: list-servers, list-tools, get-tool, and call-tool. It wraps
+ * the HTTP API endpoints and requires the MCP Hub Lite server to be running.
+ *
+ * ## Command Format
+ *
+ * ```
+ * npm run server <serverName> <action> [toolName] [--args <json>] [--tags <json>]
+ * ```
+ *
+ * ## Supported Actions
+ *
+ * - `list-servers` - List all connected MCP servers
+ * - `list-tools` - List all tools from the specified server
+ * - `get-tool <toolName>` - Get complete schema for a specific tool
+ * - `call-tool <toolName>` - Call a tool on the specified server
+ *
+ * ## Options
+ *
+ * - `--args <json>` - JSON string of tool arguments (for call-tool action)
+ * - `--tags <json>` - JSON object of instance selection tags (call-tool only, for multi-instance servers)
+ *
+ * ## Usage Examples
+ *
+ * ```bash
+ * # List all connected servers
+ * npm run server mcp-hub-lite list-servers
+ *
+ * # List all tools from a specific server
+ * npm run server mcp-hub-lite list-tools
+ *
+ * # Get tool schema
+ * npm run server mcp-hub-lite get-tool list_tools
+ *
+ * # Call a tool with arguments
+ * npm run server mcp-hub-lite call-tool list_tools --args '{"serverName":"mcp-hub-lite"}'
+ *
+ * # Call a tool with tags for multi-instance selection
+ * npm run server baidu-search call-tool search --args '{"query":"天气"}' --tags '{"env":"prod"}'
+ * ```
+ *
+ * ## Error Handling
+ *
+ * - Exits with code 1 if the server is not running
+ * - Exits with code 1 if action is unknown
+ * - Exits with code 1 if toolName is required but not provided
+ * - Exits with code 1 if JSON parsing fails for --args or --tags
+ * - Exits with code 1 if the underlying API call fails
+ *
+ * @returns {Command} The configured server command instance for registration with Commander.js
+ */
+export const serverCommand = new Command('server')
+    .description('Manage MCP server tools via API (list-servers, list-tools, get-tool, call-tool)')
+    .argument('<serverName>', 'Server name to target (use "mcp-hub-lite" for system tools)')
+    .argument('<action>', 'Action: list-servers, list-tools, get-tool, call-tool')
+    .argument('[toolName]', 'Tool name (required for get-tool and call-tool actions)')
+    .option('--args <json>', 'JSON string of tool arguments (call-tool only)')
+    .option('--tags <json>', 'JSON object of instance selection tags (call-tool only, for multi-instance servers)')
+    .action(async (serverName, action, toolName, options) => {
+    try {
+        // Check if server is running and get connection info
+        const status = await getServerStatus();
+        if (!status.running) {
+            console.error('Error: MCP Hub Lite server is not running.');
+            console.error('Start the server with: mcp-hub-lite start');
+            process.exit(1);
+        }
+        const baseUrl = `http://${status.host}:${status.port}`;
+        switch (action) {
+            case 'list-servers': {
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    throw new Error(`API error: ${response.status} ${response.statusText}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'list-tools': {
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools${tagsParam}`, {
+                    headers: { Accept: 'application/json' }
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'get-tool': {
+                if (!toolName) {
+                    console.error('Error: toolName is required for get-tool action');
+                    process.exit(1);
+                }
+                const tagsParam = options.tags ? `?tags=${encodeURIComponent(options.tags)}` : '';
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools/${toolName}${tagsParam}`, { headers: { Accept: 'application/json' } });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            case 'call-tool': {
+                if (!toolName) {
+                    console.error('Error: toolName is required for call-tool action');
+                    process.exit(1);
+                }
+                // Parse tool arguments
+                let toolArgs = {};
+                if (options.args) {
+                    try {
+                        toolArgs = JSON.parse(options.args);
+                    }
+                    catch {
+                        console.error('Error: Invalid JSON in --args option');
+                        process.exit(1);
+                    }
+                }
+                // Parse tags for instance selection (call-tool only)
+                let requestOptions;
+                if (options.tags) {
+                    try {
+                        requestOptions = { tags: JSON.parse(options.tags) };
+                    }
+                    catch {
+                        console.error('Error: Invalid JSON in --tags option');
+                        process.exit(1);
+                    }
+                }
+                const response = await fetch(`${baseUrl}/web/hub-tools/servers/${serverName}/tools/${toolName}/call`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json'
+                    },
+                    body: JSON.stringify({ toolArgs, requestOptions })
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ message: response.statusText }));
+                    throw new Error(error.message || `API error: ${response.status}`);
+                }
+                const result = await response.json();
+                console.log(JSON.stringify(result, null, 2));
+                break;
+            }
+            default: {
+                console.error(`Unknown action: ${action}`);
+                console.error('Valid actions: list-servers, list-tools, get-tool, call-tool');
+                process.exit(1);
+            }
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

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"}