@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/src/api/web/servers.d.ts

@@ -1,18 +1,18 @@
 import { FastifyInstance } from 'fastify';
 /**
- * MCP Server Management API Routes
+ * MCP Server Management API Routes (v1.1 format)
  *
  * Provides comprehensive CRUD (Create, Read, Update, Delete) operations for managing MCP (Model Context Protocol) servers
  * and their runtime instances within the MCP Hub Lite system. This module serves as the primary interface for
  * server configuration management, process control, and bulk operations.
  *
- * The API supports both static server configuration (defining how servers should be configured) and dynamic
+ * The API supports both static server template configuration and dynamic
  * instance management (controlling actual running server processes). It includes sophisticated validation
  * using Zod schemas to ensure configuration integrity and provides detailed error handling with appropriate
  * HTTP status codes.
  *
  * Key features include:
- * - Full CRUD operations for server configurations
+ * - Full CRUD operations for server templates
  * - Instance-level management for running server processes
  * - Batch import/export capabilities for server configurations
  * - Automatic server startup based on enabled status

package/dist/server/src/api/web/servers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/servers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAY1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBA4O7D"}
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/servers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAmB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBAwS7D"}

package/dist/server/src/api/web/servers.js

@@ -1,21 +1,27 @@
 import { z } from 'zod';
 import { hubManager } from '../../services/hub-manager.service.js';
-import { ServerConfigSchema, ServerInstanceConfigSchema } from '../../config/config.schema.js';
+import { ServerTemplateSchema, ServerInstanceUpdateSchema } from '../../config/config.schema.js';
 import { logger } from '../../utils/logger.js';
+import { LOG_MODULES } from '../../utils/logger/log-modules.js';
+import { stringifyForLogging, getApiDebugSetting } from '../../utils/json-utils.js';
 /**
- * MCP Server Management API Routes
+ * Server update schema that supports template fields
+ */
+const ServerUpdateSchema = ServerTemplateSchema.partial();
+/**
+ * MCP Server Management API Routes (v1.1 format)
  *
  * Provides comprehensive CRUD (Create, Read, Update, Delete) operations for managing MCP (Model Context Protocol) servers
  * and their runtime instances within the MCP Hub Lite system. This module serves as the primary interface for
  * server configuration management, process control, and bulk operations.
  *
- * The API supports both static server configuration (defining how servers should be configured) and dynamic
+ * The API supports both static server template configuration and dynamic
  * instance management (controlling actual running server processes). It includes sophisticated validation
  * using Zod schemas to ensure configuration integrity and provides detailed error handling with appropriate
  * HTTP status codes.
  *
  * Key features include:
- * - Full CRUD operations for server configurations
+ * - Full CRUD operations for server templates
  * - Instance-level management for running server processes
  * - Batch import/export capabilities for server configurations
  * - Automatic server startup based on enabled status
@@ -47,34 +53,44 @@ export async function webServerRoutes(fastify) {
     });
     // GET /web/server-instances
     fastify.get('/web/server-instances', async () => {
-        return hubManager.getServerInstances();
+        const allServers = hubManager.getAllServers();
+        const instances = {};
+        for (const { name, config } of allServers) {
+            instances[name] = config.instances;
+        }
+        return instances;
     });
     // GET /web/server-instances/:name
     fastify.get('/web/server-instances/:name', async (request, reply) => {
-        const instances = hubManager.getServerInstanceByName(request.params.name);
+        const instances = hubManager.getServerInstancesByName(request.params.name);
         if (instances.length === 0) {
-            return reply.code(404).send({ error: 'Server instances not found' });
+            // Check if server exists but has no instances
+            const server = hubManager.getServerByName(request.params.name);
+            if (!server) {
+                return reply.code(404).send({ error: 'Server not found' });
+            }
         }
         return instances;
     });
     // POST /web/servers
     fastify.post('/web/servers', async (request, reply) => {
         try {
-            // Accept server name and configuration as request body
+            // Accept server name and template configuration as request body
             const postSchema = z.object({
                 name: z.string().min(1).max(100),
-                config: ServerConfigSchema.partial()
+                config: ServerTemplateSchema.partial()
             });
             const body = postSchema.parse(request.body);
             const newServer = await hubManager.addServer(body.name, body.config);
-            // If auto-start is enabled, add server instance (addServerInstance will automatically check and handle startup)
-            if (newServer.enabled !== false && newServer.enabled !== undefined) {
+            // If auto-start is enabled, check if we need to start the instance
+            const firstInstance = newServer.instances[0];
+            if (firstInstance && firstInstance.enabled !== false) {
                 try {
-                    await hubManager.addServerInstance(body.name, {});
+                    // Instance is already created by addServer, no need to create again
                 }
                 catch (error) {
                     // Auto-start failure does not affect server addition operation
-                    logger.warn(`Failed to auto-start server instance for ${body.name}:`, error);
+                    logger.warn(`Failed to auto-start server instance for ${body.name}:`, error, LOG_MODULES.SERVER_API);
                 }
             }
             return reply.code(201).send({ name: body.name, config: newServer });
@@ -89,8 +105,13 @@ export async function webServerRoutes(fastify) {
     // POST /web/server-instances/:name
     fastify.post('/web/server-instances/:name', async (request, reply) => {
         try {
-            const instanceSchema = ServerInstanceConfigSchema.partial();
-            const body = instanceSchema.parse(request.body);
+            if (getApiDebugSetting()) {
+                logger.debug(`[API] POST /web/server-instances/${request.params.name} - raw body: ${stringifyForLogging(request.body)}`, LOG_MODULES.SERVER_API);
+            }
+            const body = ServerInstanceUpdateSchema.parse(request.body);
+            if (getApiDebugSetting()) {
+                logger.debug(`[API] POST /web/server-instances/${request.params.name} - parsed body: ${stringifyForLogging(body)}`, LOG_MODULES.SERVER_API);
+            }
             // Check if server exists
             const server = hubManager.getServerByName(request.params.name);
             if (!server) {
@@ -109,9 +130,10 @@ export async function webServerRoutes(fastify) {
     // PUT /web/servers/:name
     fastify.put('/web/servers/:name', async (request, reply) => {
         try {
-            const partialSchema = ServerConfigSchema.partial();
-            const body = partialSchema.parse(request.body);
-            const updatedServer = await hubManager.updateServer(request.params.name, body);
+            const body = ServerUpdateSchema.parse(request.body);
+            // Update server template (includes instanceSelectionStrategy in template)
+            await hubManager.updateServer(request.params.name, body);
+            const updatedServer = hubManager.getServerByName(request.params.name);
             if (!updatedServer) {
                 return reply.code(404).send({ error: 'Server not found' });
             }
@@ -127,8 +149,13 @@ export async function webServerRoutes(fastify) {
     // PUT /web/server-instances/:name/:index
     fastify.put('/web/server-instances/:name/:index', async (request, reply) => {
         try {
-            const partialSchema = ServerInstanceConfigSchema.partial();
-            const body = partialSchema.parse(request.body);
+            if (getApiDebugSetting()) {
+                logger.debug(`[API] PUT /web/server-instances/${request.params.name}/${request.params.index} - raw body: ${stringifyForLogging(request.body)}`, LOG_MODULES.SERVER_API);
+            }
+            const body = ServerInstanceUpdateSchema.parse(request.body);
+            if (getApiDebugSetting()) {
+                logger.debug(`[API] PUT /web/server-instances/${request.params.name}/${request.params.index} - parsed body: ${stringifyForLogging(body)}`, LOG_MODULES.SERVER_API);
+            }
             await hubManager.updateServerInstance(request.params.name, request.params.index, body);
             return reply.code(200).send({ message: 'Server instance updated' });
         }
@@ -160,6 +187,24 @@ export async function webServerRoutes(fastify) {
             return reply.code(500).send({ error: 'Internal Server Error' });
         }
     });
+    // POST /web/server-instances/:name/reassign-indexes
+    fastify.post('/web/server-instances/:name/reassign-indexes', async (request, reply) => {
+        try {
+            // Check if server exists
+            const server = hubManager.getServerByName(request.params.name);
+            if (!server) {
+                return reply.code(404).send({ error: 'Server not found' });
+            }
+            const success = await hubManager.reassignInstanceIndexes(request.params.name);
+            if (!success) {
+                return reply.code(404).send({ error: 'No server instances found' });
+            }
+            return reply.code(200).send({ message: 'Server instance indexes reassigned successfully' });
+        }
+        catch {
+            return reply.code(500).send({ error: 'Internal Server Error' });
+        }
+    });
     // POST /web/servers/batch
     fastify.post('/web/servers/batch', async (request, reply) => {
         try {
@@ -167,7 +212,7 @@ export async function webServerRoutes(fastify) {
             const batchSchema = z.object({
                 mcpServers: z.array(z.object({
                     name: z.string().min(1).max(100),
-                    config: ServerConfigSchema.partial()
+                    config: ServerTemplateSchema.partial()
                 }))
             });
             const body = batchSchema.parse(request.body);
@@ -192,11 +237,11 @@ export async function webServerRoutes(fastify) {
                         continue;
                     }
                     // Validate server configuration using Zod (now supports "http" type)
-                    const validatedConfig = ServerConfigSchema.partial().parse(serverConfig);
+                    const validatedConfig = ServerTemplateSchema.partial().parse(serverConfig);
                     serversToAdd.push({ name: processedName, config: validatedConfig });
-                    if (validatedConfig.enabled !== false && validatedConfig.enabled !== undefined) {
-                        serversToConnect.push(processedName);
-                    }
+                    // In v1.1, enabled is at instance level, not template level
+                    // We'll connect all instances by default
+                    serversToConnect.push(processedName);
                     results.success.push({ name: processedName, config: validatedConfig });
                     existingNames.add(processedName); // Prevent duplicates within the same batch
                 }

package/dist/server/src/api/web/sessions.js

@@ -1,4 +1,4 @@
-import { mcpSessionManager } from '../../services/mcp-session-manager.js';
+import { mcpSessionManager } from '../../services/session/index.js';
 import { logger, LOG_MODULES } from '../../utils/logger.js';
 /**
  * Session Management API Routes

package/dist/server/src/api/ws/ws-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-handler.d.ts","sourceRoot":"","sources":["../../../../../src/api/ws/ws-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAc,MAAM,gCAAgC,CAAC;AAgC7E,qBAAa,gBAAgB;IAKzB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IALlB,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,iBAAiB,CAAC,CAAiB;gBAGjC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,eAAe;IAGnC;;OAEG;IACH,UAAU,IAAI,IAAI;IAWlB;;OAEG;IACH,OAAO,CAAC,aAAa;IA6BrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,CAAC,eAAe;IA6BvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,IAAI;IAMZ;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,aAAa;CAKtB"}
+{"version":3,"file":"ws-handler.d.ts","sourceRoot":"","sources":["../../../../../src/api/ws/ws-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAC/B,OAAO,EAAE,eAAe,EAAc,MAAM,gCAAgC,CAAC;AAgC7E,qBAAa,gBAAgB;IAKzB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ;IALlB,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,iBAAiB,CAAC,CAAiB;gBAGjC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,eAAe;IAGnC;;OAEG;IACH,UAAU,IAAI,IAAI;IAWlB;;OAEG;IACH,OAAO,CAAC,aAAa;IA6BrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiBvB;;OAEG;IACH,OAAO,CAAC,eAAe;IA6BvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,IAAI;IAMZ;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,aAAa;CAKtB"}

package/dist/server/src/api/ws/ws-handler.js

@@ -99,14 +99,16 @@ export class WebSocketHandler {
      * Handle fetch historical logs request
      */
     handleFetchLogs(message) {
-        const logs = logStorage.getLogs(message.serverId, {
+        const compositeKey = `${message.serverName}-${message.serverIndex}`;
+        const logs = logStorage.getLogs(compositeKey, {
             limit: message.limit || 100,
             since: message.since
         });
         this.send({
             type: 'log',
             data: {
-                serverId: message.serverId,
+                serverName: message.serverName,
+                serverIndex: message.serverIndex,
                 logs: logs
             }
         });

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

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/app.ts"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,mWAqE7B"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/app.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,mWAmE7B"}

package/dist/server/src/app.js

@@ -14,9 +14,7 @@ import { webMcpStatusRoutes } from './api/web/mcp-status.js';
 import { configRoutes } from './api/web/config.js';
 import { webLogRoutes } from './api/web/logs.js';
 import { webHubToolsRoutes } from './api/web/hub-tools.js';
-import { webClientRoutes } from './api/web/clients.js';
 import { webResourceRoutes } from './api/web/resources.js';
-import { webSessionRoutes } from './api/web/sessions.js';
 // WebSocket Routes
 import { webSocketRoutes } from './api/ws/events.js';
 // Get __dirname equivalent in ESM
@@ -77,9 +75,7 @@ export async function buildApp() {
     fastify.register(configRoutes);
     fastify.register(webLogRoutes);
     fastify.register(webHubToolsRoutes);
-    fastify.register(webClientRoutes);
     fastify.register(webResourceRoutes);
-    fastify.register(webSessionRoutes);
     fastify.register(webSocketRoutes);
     // Serve static files from dist/client (frontend build output)
     const clientPath = path.join(__dirname, '../../client');

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);
     }
 }