@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/src/api/mcp/session-context-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-context-extractor.d.ts","sourceRoot":"","sources":["../../../../../src/api/mcp/session-context-extractor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAInE,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE;YACX,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC;QACF,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CAAC,GAAG;IAC5F,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,aAAa,CAAC;CAC9B,CAoHA"}
+{"version":3,"file":"session-context-extractor.d.ts","sourceRoot":"","sources":["../../../../../src/api/mcp/session-context-extractor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAI7E,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE;YACX,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;SACjB,CAAC;QACF,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CAAC,GAAG;IAC5F,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;CAChC,CAyFA"}

package/dist/server/src/api/mcp/session-context-extractor.js

@@ -4,7 +4,7 @@
  */
 import { logger, LOG_MODULES } from '../../utils/logger.js';
 import { randomUUID } from 'crypto';
-import { mcpSessionManager } from '../../services/mcp-session-manager.js';
+import { mcpSessionManager } from '../../services/session/index.js';
 /**
  * Extracts session context from incoming MCP requests to establish client identity and session management.
  *
@@ -19,12 +19,12 @@ import { mcpSessionManager } from '../../services/mcp-session-manager.js';
  * project information, IP address, and user agent for comprehensive session tracking.
  *
  * @param {FastifyRequest<{ Body: RequestBody | null }>} request - Incoming Fastify request object
- * @returns {{ sessionId: string; clientContext: ClientContext }} Object containing resolved session ID and enriched client context
+ * @returns {{ sessionId: string; sessionContext: SessionContext }} Object containing resolved session ID and enriched session context
  *
  * @example
  * ```typescript
- * const { sessionId, clientContext } = extractSessionContext(request);
- * console.log(`Session: ${sessionId}, Client: ${clientContext.clientName}`);
+ * const { sessionId, sessionContext } = extractSessionContext(request);
+ * console.log(`Session: ${sessionId}, Client: ${sessionContext.clientName}`);
  * ```
  */
 export function extractSessionContext(request) {
@@ -49,14 +49,14 @@ export function extractSessionContext(request) {
             logger.debug(`Extracted sessionId from URL: ${sessionId}`, LOG_MODULES.CONTEXT);
         }
     }
-    // If sessionId was extracted, check if it exists in persisted sessions (for debugging)
+    // If sessionId was extracted, check if it exists in memory (for debugging)
     if (sessionId) {
-        const persistedSession = mcpSessionManager.getSessionState(sessionId);
-        if (persistedSession) {
-            logger.debug(`Session ${sessionId} found in persisted sessions`, LOG_MODULES.CONTEXT);
+        const hasSession = mcpSessionManager.hasSession(sessionId);
+        if (hasSession) {
+            logger.debug(`Session ${sessionId} found in active sessions`, LOG_MODULES.CONTEXT);
         }
         else {
-            logger.debug(`Session ${sessionId} not found in persisted sessions (will create new)`, LOG_MODULES.CONTEXT);
+            logger.debug(`Session ${sessionId} not found in active sessions (will create new)`, LOG_MODULES.CONTEXT);
         }
     }
     // Extract client info from headers and request body
@@ -68,25 +68,10 @@ export function extractSessionContext(request) {
     if (!sessionId && isInitializeRequest && request.body?.params?.clientInfo) {
         const { name, version } = request.body.params.clientInfo;
         protocolVersion = request.body.params.protocolVersion;
-        const cwd = headers['x-mcp-cwd'] || headers['x-cwd'];
-        // Generate sessionId from client info
-        let baseId = `${name.replace(/[^a-zA-Z0-9-]/g, '')}-${version.replace(/[^a-zA-Z0-9-]/g, '')}`;
-        if (cwd) {
-            const cwdHash = cwd
-                .split('')
-                .reduce((acc, char) => {
-                acc = (acc << 5) - acc + char.charCodeAt(0);
-                return acc & acc;
-            }, 0)
-                .toString(16)
-                .replace('-', '');
-            baseId = `${baseId}-${cwdHash}`;
-        }
-        else {
-            const randomHash = randomUUID().substring(0, 8);
-            baseId = `${baseId}-${randomHash}`;
-        }
-        sessionId = baseId;
+        // Generate sessionId from client info with random hash (no cwd dependency)
+        const baseId = `${name.replace(/[^a-zA-Z0-9-]/g, '')}-${version.replace(/[^a-zA-Z0-9-]/g, '')}`;
+        const randomHash = randomUUID().substring(0, 8);
+        sessionId = `${baseId}-${randomHash}`;
         logger.debug(`Generated sessionId from initialize params: ${sessionId}`, LOG_MODULES.CONTEXT);
         // Save client version and protocol version information
         clientVersion = version;
@@ -105,23 +90,14 @@ export function extractSessionContext(request) {
             logger.debug(`Generated new sessionId: ${sessionId}`, LOG_MODULES.CONTEXT);
         }
     }
-    // Add consistency check before returning session information
-    if (sessionId && mcpSessionManager.getSessionState(sessionId)) {
-        const hasSessionObject = mcpSessionManager.hasSession(sessionId);
-        if (!hasSessionObject) {
-            logger.warn(`Session state exists but session object missing for ${sessionId}`, LOG_MODULES.CONTEXT);
-        }
-    }
-    const clientContext = {
+    const sessionContext = {
         sessionId,
         clientName,
         clientVersion,
         protocolVersion,
-        cwd: headers['x-mcp-cwd'] || headers['x-cwd'],
-        project: headers['x-mcp-project'] || headers['x-project'],
         ip: request.ip,
         userAgent: headers['user-agent'],
         timestamp: Date.now()
     };
-    return { sessionId, clientContext };
+    return { sessionId, sessionContext };
 }

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

@@ -1,4 +1,4 @@
-import { clientTrackerService } from '../../services/client-tracker.service.js';
+import { sessionTrackerService } from '../../services/session-tracker.service.js';
 import { logger } from '../../utils/logger.js';
 /**
  * Registers web API routes for client management endpoints.
@@ -30,7 +30,7 @@ import { logger } from '../../utils/logger.js';
 export async function webClientRoutes(fastify) {
     fastify.get('/api/clients', async (_request, reply) => {
         try {
-            const clients = clientTrackerService.getClients();
+            const clients = sessionTrackerService.getSessions();
             return reply.send(clients);
         }
         catch (error) {

package/dist/server/src/api/web/hub-tools.d.ts

@@ -7,12 +7,12 @@ import { FastifyInstance } from 'fastify';
  * tool management and execution within the MCP Hub Lite system.
  *
  * The API supports both system-level tools (built into MCP Hub Lite) and server-specific tools
- * from connected MCP servers. It enables powerful search capabilities, detailed tool inspection,
+ * from connected MCP servers. It enables tool listing, detailed tool inspection,
  * and secure tool invocation with proper parameter validation.
  *
  * Key features include:
  * - System tool discovery and execution
- * - Cross-server tool listing and searching
+ * - Cross-server tool listing
  * - Server-specific tool management
  * - Tool schema inspection and validation
  * - Secure tool invocation with session context

package/dist/server/src/api/web/hub-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hub-tools.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/hub-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA8B1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBA6O/D"}
+{"version":3,"file":"hub-tools.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/hub-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAoB1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBAsJ/D"}

package/dist/server/src/api/web/hub-tools.js

@@ -8,12 +8,12 @@ import { hubToolsService } from '../../services/hub-tools.service.js';
  * tool management and execution within the MCP Hub Lite system.
  *
  * The API supports both system-level tools (built into MCP Hub Lite) and server-specific tools
- * from connected MCP servers. It enables powerful search capabilities, detailed tool inspection,
+ * from connected MCP servers. It enables tool listing, detailed tool inspection,
  * and secure tool invocation with proper parameter validation.
  *
  * Key features include:
  * - System tool discovery and execution
- * - Cross-server tool listing and searching
+ * - Cross-server tool listing
  * - Server-specific tool management
  * - Tool schema inspection and validation
  * - Secure tool invocation with session context
@@ -58,16 +58,6 @@ export async function webHubToolsRoutes(fastify) {
         const servers = await hubToolsService.listServers();
         return servers;
     });
-    // GET /web/hub-tools/servers/find - Find servers matching a pattern
-    fastify.get('/web/hub-tools/servers/find', async (request) => {
-        const { pattern, searchIn = 'both', caseSensitive = 'false' } = request.query;
-        const servers = await hubToolsService.findServers({
-            pattern,
-            searchIn: searchIn,
-            caseSensitive: caseSensitive === 'true'
-        });
-        return servers;
-    });
     // GET /web/hub-tools/servers/:serverName/tools - List all tools in a specific server
     fastify.get('/web/hub-tools/servers/:serverName/tools', async (request, reply) => {
         try {
@@ -77,7 +67,7 @@ export async function webHubToolsRoutes(fastify) {
                 sessionId,
                 tags: tags ? JSON.parse(tags) : undefined
             };
-            const result = await hubToolsService.listAllToolsInServer({ serverName, requestOptions });
+            const result = await hubToolsService.listToolsInServer({ serverName, requestOptions });
             return result;
         }
         catch (error) {
@@ -87,37 +77,6 @@ export async function webHubToolsRoutes(fastify) {
             });
         }
     });
-    // GET /web/hub-tools/servers/:serverName/tools/find - Find tools in a specific server
-    fastify.get('/web/hub-tools/servers/:serverName/tools/find', async (request, reply) => {
-        try {
-            const { serverName } = request.params;
-            const { pattern, searchIn = 'both', caseSensitive = 'false', sessionId, tags } = request.query;
-            const requestOptions = {
-                sessionId,
-                tags: tags ? JSON.parse(tags) : undefined
-            };
-            const result = await hubToolsService.findToolsInServer({
-                serverName,
-                pattern,
-                searchIn: searchIn,
-                caseSensitive: caseSensitive === 'true',
-                requestOptions
-            });
-            return result;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('not found')) {
-                return reply.code(404).send({
-                    error: 'Server not found',
-                    message: error.message
-                });
-            }
-            return reply.code(500).send({
-                error: 'Internal Server Error',
-                message: error instanceof Error ? error.message : 'Unknown error'
-            });
-        }
-    });
     // GET /web/hub-tools/servers/:serverName/tools/:toolName - Get specific tool details
     fastify.get('/web/hub-tools/servers/:serverName/tools/:toolName', async (request, reply) => {
         try {
@@ -192,14 +151,4 @@ export async function webHubToolsRoutes(fastify) {
         const allTools = await hubToolsService.listAllTools();
         return allTools;
     });
-    // GET /web/hub-tools/tools/find - Find tools matching a pattern across all servers
-    fastify.get('/web/hub-tools/tools/find', async (request) => {
-        const { pattern, searchIn = 'both', caseSensitive = 'false' } = request.query;
-        const tools = await hubToolsService.findTools({
-            pattern,
-            searchIn: searchIn,
-            caseSensitive: caseSensitive === 'true'
-        });
-        return tools;
-    });
 }

package/dist/server/src/api/web/mcp-status.d.ts

@@ -1,6 +1,6 @@
 import { FastifyInstance } from 'fastify';
 /**
- * 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,

package/dist/server/src/api/web/mcp-status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-status.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/mcp-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAO1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,iBAsHhE"}
+{"version":3,"file":"mcp-status.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/mcp-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAQ1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,iBAuKhE"}

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