@mcp-shark/mcp-shark 1.4.1 → 1.4.2

package/mcp-server/lib/auditor/audit.js

@@ -135,14 +135,22 @@ export async function withAuditRequestResponseHandler(
   transport,
   req,
   res,
-  auditLogger
+  auditLogger,
+  requestedMcpServer,
+  initialSessionId
 ) {
   const reqBuf = await readBody(req);
   const reqJsonRpc = tryParseJsonRpc(reqBuf);
 
   // Extract session ID from request
   // If no session ID exists, it's an initiation request
-  const sessionId = getSessionFromRequest(req);
+  const sessionIdFromRequest = getSessionFromRequest(req);
+  const sessionId =
+    sessionIdFromRequest === null ||
+    sessionIdFromRequest === undefined ||
+    sessionIdFromRequest === ''
+      ? initialSessionId
+      : sessionIdFromRequest;
 
   // Extract request body as string
   const reqBodyStr = reqBuf.toString('utf8');
@@ -161,7 +169,7 @@ export async function withAuditRequestResponseHandler(
     headers: req.headers,
     body: reqBodyJson || reqBodyStr,
     userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
-    remoteAddress: req.socket?.remoteAddress || null,
+    remoteAddress: requestedMcpServer,
     sessionId: sessionId || null,
   });
 
@@ -223,6 +231,6 @@ export async function withAuditRequestResponseHandler(
     jsonrpcId,
     sessionId: sessionId || null,
     userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
-    remoteAddress: req.socket?.remoteAddress || null,
+    remoteAddress: requestedMcpServer || null,
   });
 }

package/mcp-server/lib/server/external/kv.js

@@ -1,14 +1,5 @@
 const kv = new Map();
 
-function buildName(name, typeName) {
-  return `${name}.${typeName}`;
-}
-
-export function extractName(name) {
-  const [serverName, typeName] = name.split('.');
-  return { serverName, typeName };
-}
-
 export function buildKv(downstreamServers) {
   for (const downstreamServer of downstreamServers) {
     const {
@@ -43,16 +34,16 @@ export function buildKv(downstreamServers) {
         resourcesMap,
         promptsMap,
         tools: tools.map(tool => {
-          return { ...tool, name: buildName(name, tool.name) };
+          return { ...tool, name: tool.name };
         }),
         resources: resources.map(resource => {
           return {
             ...resource,
-            name: buildName(name, resource.name),
+            name: resource.name,
           };
         }),
         prompts: prompts.map(prompt => {
-          return { ...prompt, name: buildName(name, prompt.name) };
+          return { ...prompt, name: prompt.name };
         }),
       });
     }
@@ -61,42 +52,40 @@ export function buildKv(downstreamServers) {
   return kv;
 }
 
-export function getBy(database, calledName, action) {
-  const { serverName, typeName } = extractName(calledName);
-  if (!serverName || !typeName) {
-    return null;
-  }
-  const entry = database.get(serverName);
+export function getBy(database, requestedMcpServer, calledName, action) {
+  const entry = database.get(requestedMcpServer);
   if (!entry) {
     return null;
   }
 
   // Type-based lookup
   if (action === 'getTools') {
-    return entry.toolsMap.get(typeName);
+    return entry.toolsMap.get(calledName);
   }
   if (action === 'getResources') {
-    return entry.resourcesMap.get(typeName);
+    return entry.resourcesMap.get(calledName);
   }
   if (action === 'getPrompts') {
-    return entry.promptsMap.get(typeName);
+    return entry.promptsMap.get(calledName);
   }
 
   // Action-based lookup
   if (action === 'callTool') {
-    return entry.toolsMap.get(typeName);
+    return entry.toolsMap.get(calledName);
   }
   if (action === 'readResource') {
-    return entry.resourcesMap.get(typeName);
+    return entry.resourcesMap.get(calledName);
   }
   if (action === 'getPrompt') {
-    return entry.promptsMap.get(typeName);
+    return entry.promptsMap.get(calledName);
   }
   return null;
 }
 
-export function listAll(database, type) {
-  return Array.from(database.values())
-    .map(entry => entry[type])
-    .flat();
+export function listAll(database, requestedMcpServer, type) {
+  const serverEntry = database.get(requestedMcpServer);
+  if (!serverEntry) {
+    return [];
+  }
+  return serverEntry[type];
 }

package/mcp-server/lib/server/internal/handlers/prompts-get.js

@@ -1,20 +1,28 @@
-import { getBy, extractName } from '../../external/kv.js';
+import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
-export function createPromptsGetHandler(logger, mcpServers) {
+export function createPromptsGetHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
   return async req => {
     const name = req.params.name;
     const promptArgs = req?.params?.arguments || {};
     logger.debug('Prompt get', name, promptArgs);
 
-    const { typeName } = extractName(name);
-
-    const getPrompt = getBy(mcpServers, name, 'getPrompt', promptArgs);
+    const getPrompt = getBy(
+      mcpServers,
+      requestedMcpServer,
+      name,
+      'getPrompt',
+      promptArgs
+    );
     if (!getPrompt) {
       throw new InternalServerError(`Prompt not found: ${name}`);
     }
 
-    const result = await getPrompt(typeName, promptArgs);
+    const result = await getPrompt(name, promptArgs);
     logger.debug('Prompt get result', result);
 
     return result;

package/mcp-server/lib/server/internal/handlers/prompts-list.js

@@ -1,10 +1,15 @@
 import { listAll } from '../../external/kv.js';
 
-export function createPromptsListHandler(logger, mcpServers) {
-  return async _req => {
-    logger.debug('Prompts list');
+export function createPromptsListHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
+  return async req => {
+    const path = req.path;
+    logger.debug('Prompts list', path);
 
-    const res = await listAll(mcpServers, 'prompts');
+    const res = await listAll(mcpServers, requestedMcpServer, 'prompts');
     const result = Array.isArray(res) ? { prompts: res } : res;
 
     return result;

package/mcp-server/lib/server/internal/handlers/resources-list.js

@@ -1,10 +1,15 @@
 import { listAll } from '../../external/kv.js';
 
-export function createResourcesListHandler(logger, mcpServers) {
-  return async _req => {
-    logger.debug('Resources list');
+export function createResourcesListHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
+  return async req => {
+    const path = req.path;
+    logger.debug('Resources list', path);
 
-    const res = await listAll(mcpServers, 'resources');
+    const res = await listAll(mcpServers, requestedMcpServer, 'resources');
     const result = Array.isArray(res) ? { resources: res } : res;
 
     return result;

package/mcp-server/lib/server/internal/handlers/resources-read.js

@@ -1,12 +1,22 @@
 import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
-export function createResourcesReadHandler(logger, mcpServers) {
+export function createResourcesReadHandler(
+  logger,
+  mcpServers,
+  requestedMcpServer
+) {
   return async req => {
+    const path = req.path;
     const uri = req.params.uri;
-    logger.debug('Resource read', uri);
+    logger.debug('Resource read', path, uri);
 
-    const readResource = getBy(mcpServers, uri, 'readResource');
+    const readResource = getBy(
+      mcpServers,
+      requestedMcpServer,
+      uri,
+      'readResource'
+    );
     if (!readResource) {
       throw new InternalServerError(`Resource not found: ${uri}`);
     }

package/mcp-server/lib/server/internal/handlers/tools-call.js

@@ -1,24 +1,28 @@
-import { getBy, extractName } from '../../external/kv.js';
+import { getBy } from '../../external/kv.js';
 import { InternalServerError } from './error.js';
 
 const isAsyncIterable = v => v && typeof v[Symbol.asyncIterator] === 'function';
 
-export function createToolsCallHandler(logger, mcpServers) {
+export function createToolsCallHandler(logger, mcpServers, requestedMcpServer) {
   return async req => {
+    const path = req.path;
     const { name, arguments: args } = req.params;
-    logger.debug('Tool call', name, args);
+    logger.debug('Tool call', path, name, args);
 
-    // Extract real server name from concatenated name
-    const { typeName } = extractName(name);
-
-    const callTool = getBy(mcpServers, name, 'callTool', args || {});
+    const callTool = getBy(
+      mcpServers,
+      requestedMcpServer,
+      name,
+      'callTool',
+      args || {}
+    );
     if (!callTool) {
       throw new InternalServerError(`Tool not found: ${name}`);
     }
 
     const result = await callTool({
       ...req.params,
-      name: typeName,
+      name,
     });
     logger.debug('Tool call result', result);
 

package/mcp-server/lib/server/internal/handlers/tools-list.js

@@ -1,10 +1,11 @@
 import { listAll } from '../../external/kv.js';
 
-export function createToolsListHandler(logger, mcpServers) {
+export function createToolsListHandler(logger, mcpServers, requestedMcpServer) {
   return async req => {
-    logger.debug('Listing tools', req);
+    const path = req.path;
+    logger.debug('Listing tools', path);
 
-    const res = await listAll(mcpServers, 'tools');
+    const res = await listAll(mcpServers, requestedMcpServer, 'tools');
     logger.debug('Tools list result', res);
 
     const result = Array.isArray(res) ? { tools: res } : res;

package/mcp-server/lib/server/internal/run.js

@@ -22,7 +22,7 @@ export function getInternalServer(
     })
   );
 
-  app.all('/mcp', async (req, res) => {
+  app.all('/mcp/*', async (req, res) => {
     await withSession(
       serverFactory,
       withAuditRequestResponseHandler,

package/mcp-server/lib/server/internal/server.js

@@ -15,49 +15,49 @@ import { createPromptsListHandler } from './handlers/prompts-list.js';
 import { createPromptsGetHandler } from './handlers/prompts-get.js';
 import { createResourcesListHandler } from './handlers/resources-list.js';
 import { createResourcesReadHandler } from './handlers/resources-read.js';
-import { SERVER_NAME } from './handlers/common.js';
 
-export function createInternalServer(logger, mcpServers) {
+export function createInternalServer(logger, mcpServers, requestedMcpServer) {
   // create MCP server
   const server = new Server(
-    { name: SERVER_NAME, version: '1.0.0' },
+    { name: requestedMcpServer, version: '1.0.0' },
     { capabilities: { tools: {}, prompts: {}, resources: {} } }
   );
 
   // Register handlers
   server.setRequestHandler(
     ListToolsRequestSchema,
-    createToolsListHandler(logger, mcpServers)
+    createToolsListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     CallToolRequestSchema,
-    createToolsCallHandler(logger, mcpServers)
+    createToolsCallHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ListPromptsRequestSchema,
-    createPromptsListHandler(logger, mcpServers)
+    createPromptsListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     GetPromptRequestSchema,
-    createPromptsGetHandler(logger, mcpServers)
+    createPromptsGetHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ListResourcesRequestSchema,
-    createResourcesListHandler(logger, mcpServers)
+    createResourcesListHandler(logger, mcpServers, requestedMcpServer)
   );
 
   server.setRequestHandler(
     ReadResourceRequestSchema,
-    createResourcesReadHandler(logger, mcpServers)
+    createResourcesReadHandler(logger, mcpServers, requestedMcpServer)
   );
 
   return server;
 }
 
 export function createInternalServerFactory(logger, mcpServers) {
-  return () => createInternalServer(logger, mcpServers);
+  return requestedMcpServer =>
+    createInternalServer(logger, mcpServers, requestedMcpServer);
 }

package/mcp-server/lib/server/internal/session.js

@@ -20,20 +20,28 @@ export async function withSession(
   res,
   auditLogger
 ) {
+  const requestedMcpServer = req.params[0];
   const sessionId = getSessionFromRequest(req);
   if (!sessionId) {
-    const newSessionId = randomUUID();
+    const initialSessionId = randomUUID();
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => newSessionId,
+      sessionIdGenerator: () => initialSessionId,
       enableJsonResponse: true,
     });
-    const server = serverFactory();
+    const server = serverFactory(requestedMcpServer);
     await server.connect(transport);
-    storeTransportInSession(newSessionId, transport);
+    storeTransportInSession(initialSessionId, transport);
     // Session creation will be logged as part of the request packet in audit.js
-    return requestHandler(transport, req, res, auditLogger);
+    return requestHandler(
+      transport,
+      req,
+      res,
+      auditLogger,
+      requestedMcpServer,
+      initialSessionId
+    );
   }
 
   const transport = getTransportFromSession(sessionId);
-  return requestHandler(transport, req, res, auditLogger);
+  return requestHandler(transport, req, res, auditLogger, requestedMcpServer);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-shark/mcp-shark",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Aggregate multiple Model Context Protocol (MCP) servers into a single unified interface with a powerful monitoring UI. Prov deep visibility into every request and response.",
   "type": "module",
   "main": "./bin/mcp-shark.js",

package/ui/server/routes/composite.js

@@ -240,5 +240,21 @@ export function createCompositeRoutes(
     });
   };
 
+  router.getServers = (req, res) => {
+    try {
+      const mcpsJsonPath = getMcpConfigPath();
+      if (!fs.existsSync(mcpsJsonPath)) {
+        return res.json({ servers: [] });
+      }
+
+      const configContent = fs.readFileSync(mcpsJsonPath, 'utf-8');
+      const config = JSON.parse(configContent);
+      const servers = config.servers ? Object.keys(config.servers) : [];
+      res.json({ servers });
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to get servers', details: error.message });
+    }
+  };
+
   return router;
 }

package/ui/server/routes/playground.js

@@ -1,20 +1,31 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 
-const MCP_SERVER_URL = 'http://localhost:9851/mcp';
+const MCP_SERVER_BASE_URL = 'http://localhost:9851/mcp';
 
-// Store client connections per session
+// Store client connections per server and session
 const clientSessions = new Map();
 
+function getSessionKey(serverName, sessionId) {
+  return `${serverName}:${sessionId}`;
+}
+
 export function createPlaygroundRoutes() {
   const router = {};
 
-  // Get or create client for a session
-  async function getClient(sessionId) {
-    if (clientSessions.has(sessionId)) {
-      return clientSessions.get(sessionId);
+  // Get or create client for a session and server
+  async function getClient(serverName, sessionId) {
+    const sessionKey = getSessionKey(serverName, sessionId);
+    if (clientSessions.has(sessionKey)) {
+      return clientSessions.get(sessionKey);
+    }
+
+    if (!serverName) {
+      throw new Error('Server name is required');
     }
 
+    const mcpServerUrl = `${MCP_SERVER_BASE_URL}/${encodeURIComponent(serverName)}`;
+
     const client = new Client(
       { name: 'mcp-shark-playground', version: '1.0.0' },
       {
@@ -26,7 +37,7 @@ export function createPlaygroundRoutes() {
       }
     );
 
-    const transport = new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL));
+    const transport = new StreamableHTTPClientTransport(new URL(mcpServerUrl));
     await client.connect(transport);
 
     const clientWrapper = {
@@ -38,13 +49,13 @@ export function createPlaygroundRoutes() {
       },
     };
 
-    clientSessions.set(sessionId, clientWrapper);
+    clientSessions.set(sessionKey, clientWrapper);
     return clientWrapper;
   }
 
   router.proxyRequest = async (req, res) => {
     try {
-      const { method, params } = req.body;
+      const { method, params, serverName } = req.body;
 
       if (!method) {
         return res.status(400).json({
@@ -53,13 +64,20 @@ export function createPlaygroundRoutes() {
         });
       }
 
+      if (!serverName) {
+        return res.status(400).json({
+          error: 'Invalid request',
+          message: 'serverName field is required',
+        });
+      }
+
       // Get or create session ID
       const sessionId =
         req.headers['mcp-session-id'] ||
         req.headers['x-mcp-session-id'] ||
         `playground-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 
-      const { client } = await getClient(sessionId);
+      const { client } = await getClient(serverName, sessionId);
 
       let result;
       switch (method) {
@@ -140,10 +158,23 @@ export function createPlaygroundRoutes() {
   // Cleanup endpoint to close client connections
   router.cleanup = async (req, res) => {
     const sessionId = req.headers['mcp-session-id'] || req.headers['x-mcp-session-id'];
-    if (sessionId && clientSessions.has(sessionId)) {
-      const clientWrapper = clientSessions.get(sessionId);
-      await clientWrapper.close();
-      clientSessions.delete(sessionId);
+    const { serverName } = req.body || {};
+
+    if (serverName && sessionId) {
+      const sessionKey = getSessionKey(serverName, sessionId);
+      if (clientSessions.has(sessionKey)) {
+        const clientWrapper = clientSessions.get(sessionKey);
+        await clientWrapper.close();
+        clientSessions.delete(sessionKey);
+      }
+    } else if (sessionId) {
+      // Cleanup all sessions for this sessionId across all servers
+      for (const [key, clientWrapper] of clientSessions.entries()) {
+        if (key.endsWith(`:${sessionId}`)) {
+          await clientWrapper.close();
+          clientSessions.delete(key);
+        }
+      }
     }
     res.json({ success: true });
   };