@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.0

package/dist/server/src/api/web/mcp-status.js

@@ -2,8 +2,9 @@ import { hubManager } from '../../services/hub-manager.service.js';
 import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
 import { logger } from '../../utils/logger.js';
 import { LOG_MODULES } from '../../utils/logger/log-modules.js';
+import { resolveInstanceConfig } from '../../config/config-migrator.js';
 /**
- * MCP Connection Status API Routes
+ * MCP Connection Status API Routes (v1.1 format)
  *
  * Provides real-time monitoring and management endpoints for MCP (Model Context Protocol) server connections.
  * This module enables administrators to check the health of connected servers, manage connection states,
@@ -33,16 +34,16 @@ export async function webMcpStatusRoutes(fastify) {
     fastify.get('/web/mcp/status', async (_request, reply) => {
         try {
             const servers = hubManager.getAllServers();
-            const serverInstances = hubManager.getServerInstances();
             const statusList = [];
             servers.forEach((server) => {
-                const instances = serverInstances[server.name] || [];
-                instances.forEach((instance) => {
+                const instances = server.config.instances || [];
+                // If no instances, add a default disconnected entry for this server
+                if (instances.length === 0) {
                     statusList.push({
-                        id: instance.id || '',
+                        id: server.name,
                         name: server.name,
-                        type: server.config.type,
-                        status: mcpConnectionManager.getStatus(instance.id || '') || {
+                        type: server.config.template.type,
+                        status: {
                             connected: false,
                             lastCheck: Date.now(),
                             toolsCount: 0,
@@ -50,7 +51,25 @@ export async function webMcpStatusRoutes(fastify) {
                             pid: undefined
                         }
                     });
-                });
+                }
+                else {
+                    // Add status for each instance
+                    instances.forEach((instance) => {
+                        const resolvedConfig = resolveInstanceConfig(server.config, instance.id);
+                        statusList.push({
+                            id: instance.id || '',
+                            name: server.name,
+                            type: resolvedConfig?.type || server.config.template.type,
+                            status: mcpConnectionManager.getStatus(server.name, instance.index ?? 0) || {
+                                connected: false,
+                                lastCheck: Date.now(),
+                                toolsCount: 0,
+                                resourcesCount: 0,
+                                pid: undefined
+                            }
+                        });
+                    });
+                }
             });
             return statusList;
         }
@@ -62,19 +81,34 @@ export async function webMcpStatusRoutes(fastify) {
     // POST /web/mcp/servers/:id/connect - Connect to MCP server
     fastify.post('/web/mcp/servers/:id/connect', async (request, reply) => {
         try {
-            const server = hubManager.getServerById(request.params.id);
-            if (!server) {
+            const serverInfo = hubManager.getServerById(request.params.id);
+            if (!serverInfo) {
                 return reply.code(404).send({ error: 'Server not found' });
             }
-            const success = await mcpConnectionManager.connect({
-                ...server.config,
-                ...server.instance
-            });
+            const resolvedConfig = resolveInstanceConfig(serverInfo.config, serverInfo.instance.id);
+            if (!resolvedConfig) {
+                return reply.code(404).send({ error: 'Server instance configuration not found' });
+            }
+            // Create a compatible config object with required instance fields
+            const connectConfig = {
+                ...resolvedConfig,
+                id: serverInfo.instance.id,
+                timestamp: Date.now(),
+                hash: '',
+                pid: undefined,
+                startTime: undefined,
+                index: serverInfo.instance.index,
+                displayName: serverInfo.instance.displayName
+            };
+            const instanceIndex = serverInfo.instance.index ?? 0;
+            const success = await mcpConnectionManager.connect(serverInfo.name, instanceIndex, connectConfig);
             if (!success) {
                 return reply.code(500).send({ error: 'Failed to connect to server' });
             }
-            // Update enabled status in config - The enabled field now belongs to server configuration, not instance configuration
-            await hubManager.updateServer(server.name, { enabled: true });
+            // Note: Do NOT update the instance's enabled field here.
+            // The enabled field is a configuration parameter that should only be modified
+            // by the user explicitly via the configuration panel.
+            // Runtime connect/disconnect operations should not affect persistent configuration.
             return { success: true };
         }
         catch (error) {
@@ -85,13 +119,15 @@ export async function webMcpStatusRoutes(fastify) {
     // POST /web/mcp/servers/:id/disconnect - Disconnect from MCP server
     fastify.post('/web/mcp/servers/:id/disconnect', async (request, reply) => {
         try {
-            await mcpConnectionManager.disconnect(request.params.id);
-            // Update enabled status in config to ensure it doesn't show as "starting"
-            // The enabled field now belongs to server configuration, not instance configuration
-            const server = hubManager.getServerById(request.params.id);
-            if (server) {
-                await hubManager.updateServer(server.name, { enabled: false });
+            const serverInfo = hubManager.getServerById(request.params.id);
+            if (!serverInfo) {
+                return reply.code(404).send({ error: 'Server not found' });
             }
+            await mcpConnectionManager.disconnect(serverInfo.name, serverInfo.instance.index ?? 0);
+            // Note: Do NOT update the instance's enabled field here.
+            // The enabled field is a configuration parameter that should only be modified
+            // by the user explicitly via the configuration panel.
+            // Runtime connect/disconnect operations should not affect persistent configuration.
             return { success: true };
         }
         catch (error) {
@@ -99,11 +135,14 @@ export async function webMcpStatusRoutes(fastify) {
             return reply.code(500).send({ error: 'Internal Server Error' });
         }
     });
-    // GET /web/mcp/servers/:id/tools - Get tools for a specific server
-    fastify.get('/web/mcp/servers/:id/tools', async (request, reply) => {
+    // GET /web/mcp/servers/:name/tools - Get tools for a specific server
+    fastify.get('/web/mcp/servers/:name/tools', async (request, reply) => {
         try {
-            logger.info(`API request tools for server: ${request.params.id}`, LOG_MODULES.MCP_STATUS);
-            const tools = mcpConnectionManager.getTools(request.params.id);
+            const serverName = request.params.name;
+            logger.info(`API request tools for server: ${serverName}`, LOG_MODULES.MCP_STATUS);
+            // Use getToolsByServerName which queries serverNameToolCache
+            // This aggregates tools from all instances of the same server name
+            const tools = mcpConnectionManager.getToolsByServerName(serverName);
             return tools;
         }
         catch (error) {
@@ -111,11 +150,13 @@ export async function webMcpStatusRoutes(fastify) {
             return reply.code(500).send({ error: 'Internal Server Error' });
         }
     });
-    // GET /web/mcp/servers/:id/resources - Get resources for a specific server
-    fastify.get('/web/mcp/servers/:id/resources', async (request, reply) => {
+    // GET /web/mcp/servers/:name/resources - Get resources for a specific server
+    fastify.get('/web/mcp/servers/:name/resources', async (request, reply) => {
         try {
-            logger.info(`API request resources for server: ${request.params.id}`, LOG_MODULES.MCP_STATUS);
-            const resources = mcpConnectionManager.getResources(request.params.id);
+            const serverName = request.params.name;
+            logger.info(`API request resources for server: ${serverName}`, LOG_MODULES.MCP_STATUS);
+            // Use getResourcesByName which queries resourceCache by server name
+            const resources = mcpConnectionManager.getResourcesByName(serverName);
             return resources;
         }
         catch (error) {

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

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBA2E/D"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBAkF/D"}

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

@@ -1,4 +1,3 @@
-import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
 import { hubToolsService } from '../../services/hub-tools.service.js';
 import { MCP_HUB_LITE_SERVER } from '../../models/system-tools.constants.js';
 /**
@@ -38,29 +37,44 @@ export async function webResourceRoutes(fastify) {
             // Handle system resources (mcp-hub-lite)
             if (name === MCP_HUB_LITE_SERVER) {
                 const content = await hubToolsService.readResource(uri);
+                // Determine mimeType and format content appropriately
+                let mimeType = 'application/json';
+                let text;
+                // Use-guide is markdown
+                if (uri === 'hub://use-guide') {
+                    mimeType = 'text/markdown';
+                    text = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+                }
+                else {
+                    // Server metadata is JSON
+                    mimeType = 'application/json';
+                    text = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+                }
                 // Wrap content in MCP resource read format
                 return {
                     contents: [
                         {
                             uri,
-                            mimeType: 'application/json',
-                            text: JSON.stringify(content, null, 2)
+                            mimeType,
+                            text
                         }
                     ]
                 };
             }
-            // Find server ID
-            const serverId = mcpConnectionManager.getServerIdByName(name);
-            if (!serverId) {
-                // Try using name directly as ID (unlikely but for robustness)
-                if (mcpConnectionManager.getStatus(name)) {
-                    const result = await mcpConnectionManager.readResource(name, uri);
-                    return result;
+            // Use hubToolsService.readResource to handle Hub URI -> MCP URI conversion
+            // This properly maps hub://servers/{name}/{instanceIndex}/{mcpPath} to MCP native URI
+            try {
+                // hubToolsService.readResource already returns MCP format for forwarding case
+                return await hubToolsService.readResource(uri);
+            }
+            catch (error) {
+                const errorObj = error;
+                if (errorObj.message.includes('not found') ||
+                    errorObj.message.includes('not connected')) {
+                    return reply.code(404).send({ error: errorObj.message });
                 }
-                return reply.code(404).send({ error: 'Server not connected or not found' });
+                return reply.code(500).send({ error: errorObj.message });
             }
-            const result = await mcpConnectionManager.readResource(serverId, uri);
-            return result;
         }
         catch (error) {
             const errorObj = error;
@@ -69,20 +83,12 @@ export async function webResourceRoutes(fastify) {
     });
     fastify.get('/web/resources', async (_request, reply) => {
         try {
-            const allResources = mcpConnectionManager.getAllResources();
-            // Add Hub System resources
+            // Return only Hub System resources (dynamically generated hub:// format)
             const systemResources = await hubToolsService.listResources();
             const resources = {};
-            // 1. Add Hub System resources first if they exist
             if (systemResources && systemResources.length > 0) {
                 resources[MCP_HUB_LITE_SERVER] = systemResources;
             }
-            // 2. Add other server resources, filtering out empty ones
-            for (const [serverName, serverResources] of Object.entries(allResources)) {
-                if (serverResources && serverResources.length > 0) {
-                    resources[serverName] = serverResources;
-                }
-            }
             return { resources };
         }
         catch (error) {

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

@@ -2,25 +2,11 @@ import { FastifyInstance } from 'fastify';
 /**
  * Tool Search API Routes
  *
- * Provides powerful fuzzy search capabilities for discovering tools across all connected MCP (Model Context Protocol) servers.
- * This module enables users to quickly find relevant tools based on name, description, or other metadata using
- * advanced search algorithms with pagination support.
- *
- * The search API supports flexible query parameters including result limits, offsets for pagination,
- * and various search modes. It integrates with the core search service to provide fast and accurate
- * tool discovery across the entire MCP ecosystem.
- *
- * Additionally includes a dedicated health check endpoint for monitoring the search service availability
- * in production environments.
+ * Provides simple string-based search for discovering tools across all connected MCP servers.
+ * Uses straightforward string matching on tool name and description.
  *
  * @param fastify - The Fastify instance to register routes on
  * @returns Promise that resolves when all routes are registered
- *
- * @example
- * ```typescript
- * // Register search routes
- * await webSearchRoutes(app);
- * ```
  */
 export declare function webSearchRoutes(fastify: FastifyInstance): Promise<void>;
 //# sourceMappingURL=search.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBA+C7D"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBAsC7D"}

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

@@ -1,62 +1,41 @@
-import { searchCoreService } from '../../services/search/search-core.service.js';
+import { mcpConnectionManager } from '../../services/mcp-connection-manager.js';
 /**
  * Tool Search API Routes
  *
- * Provides powerful fuzzy search capabilities for discovering tools across all connected MCP (Model Context Protocol) servers.
- * This module enables users to quickly find relevant tools based on name, description, or other metadata using
- * advanced search algorithms with pagination support.
- *
- * The search API supports flexible query parameters including result limits, offsets for pagination,
- * and various search modes. It integrates with the core search service to provide fast and accurate
- * tool discovery across the entire MCP ecosystem.
- *
- * Additionally includes a dedicated health check endpoint for monitoring the search service availability
- * in production environments.
+ * Provides simple string-based search for discovering tools across all connected MCP servers.
+ * Uses straightforward string matching on tool name and description.
  *
  * @param fastify - The Fastify instance to register routes on
  * @returns Promise that resolves when all routes are registered
- *
- * @example
- * ```typescript
- * // Register search routes
- * await webSearchRoutes(app);
- * ```
  */
 export async function webSearchRoutes(fastify) {
-    // GET /web/search - Search for tools with query and optional filters
+    // GET /web/search - Search for tools with simple string matching
     fastify.get('/web/search', async (request) => {
-        const { q, limit, offset } = request.query;
-        // Parse search options
-        const options = {
-            mode: 'fuzzy',
-            limit: limit ? Number(limit) : 50,
-            offset: offset ? Number(offset) : 0,
-            filters: {}
-        };
-        // Perform search
-        const results = await searchCoreService.search(q || '', options);
+        const { q, limit = 50 } = request.query;
+        const allTools = mcpConnectionManager.getAllTools();
+        const query = q?.toLowerCase() || '';
+        const filtered = allTools.filter((tool) => {
+            if (!query)
+                return true;
+            const nameMatch = tool.name.toLowerCase().includes(query);
+            const descMatch = tool.description?.toLowerCase().includes(query);
+            return nameMatch || descMatch;
+        });
+        const results = filtered.slice(0, limit);
         return {
-            results,
+            results: results.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                serverName: tool.serverName
+            })),
             pagination: {
-                total: results.length,
-                limit: options.limit,
-                offset: options.offset,
-                hasMore: results.length >= options.limit
+                total: filtered.length,
+                limit,
+                returned: results.length
             },
             metadata: {
-                query: q,
-                filters: options.filters,
-                processingTime: 0, // To be implemented: measure processing time
-                cached: false // To be implemented: check cache status
+                query: q
             }
         };
     });
-    // GET /web/search/health - Search service health check (for monitoring)
-    fastify.get('/web/search/health', async () => {
-        return {
-            status: 'healthy',
-            timestamp: new Date().toISOString(),
-            service: 'search-core-service'
-        };
-    });
 }

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/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":"AA4BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,mWAoE7B"}
+{"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

@@ -15,7 +15,6 @@ import { configRoutes } from './api/web/config.js';
 import { webLogRoutes } from './api/web/logs.js';
 import { webHubToolsRoutes } from './api/web/hub-tools.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,7 +76,6 @@ export async function buildApp() {
     fastify.register(webLogRoutes);
     fastify.register(webHubToolsRoutes);
     fastify.register(webResourceRoutes);
-    fastify.register(webSessionRoutes);
     fastify.register(webSocketRoutes);
     // Serve static files from dist/client (frontend build output)
     const clientPath = path.join(__dirname, '../../client');