@mcp-shark/mcp-shark 1.4.1 → 1.5.0

package/ui/server/routes/conversations.js

@@ -1,12 +1,12 @@
-import { serializeBigInt } from '../utils/serialization.js';
 import { queryConversations } from 'mcp-shark-common/db/query.js';
+import { serializeBigInt } from '../utils/serialization.js';
 
 export function createConversationsRoutes(db) {
   const router = {};
 
   router.getConversations = (req, res) => {
-    const limit = parseInt(req.query.limit) || 1000;
-    const offset = parseInt(req.query.offset) || 0;
+    const limit = Number.parseInt(req.query.limit) || 1000;
+    const offset = Number.parseInt(req.query.offset) || 0;
     const filters = {
       sessionId: req.query.sessionId || null,
       method: req.query.method || null,

package/ui/server/routes/help.js

@@ -3,7 +3,7 @@ import { readHelpState, writeHelpState } from 'mcp-shark-common/configs/index.js
 export function createHelpRoutes() {
   const router = {};
 
-  router.getState = (req, res) => {
+  router.getState = (_req, res) => {
     const state = readHelpState();
     res.json({
       dismissed: state.dismissed || false,
@@ -25,7 +25,7 @@ export function createHelpRoutes() {
     }
   };
 
-  router.reset = (req, res) => {
+  router.reset = (_req, res) => {
     const state = {
       dismissed: false,
       tourCompleted: false,

package/ui/server/routes/logs.js

@@ -1,19 +1,19 @@
-export function createLogsRoutes(mcpSharkLogs, broadcastLogUpdate) {
+export function createLogsRoutes(mcpSharkLogs, _broadcastLogUpdate) {
   const router = {};
 
   router.getLogs = (req, res) => {
-    const limit = parseInt(req.query.limit) || 1000;
-    const offset = parseInt(req.query.offset) || 0;
+    const limit = Number.parseInt(req.query.limit) || 1000;
+    const offset = Number.parseInt(req.query.offset) || 0;
     const logs = [...mcpSharkLogs].reverse().slice(offset, offset + limit);
     res.json(logs);
   };
 
-  router.clearLogs = (req, res) => {
+  router.clearLogs = (_req, res) => {
     mcpSharkLogs.length = 0;
     res.json({ success: true, message: 'Logs cleared' });
   };
 
-  router.exportLogs = (req, res) => {
+  router.exportLogs = (_req, res) => {
     try {
       const logsText = mcpSharkLogs
         .map((log) => `[${log.timestamp}] [${log.type.toUpperCase()}] ${log.line}`)

package/ui/server/routes/playground.js

@@ -1,20 +1,32 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import logger from '../utils/logger.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 +38,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 +50,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,64 +65,68 @@ 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);
-
-      let result;
-      switch (method) {
-        case 'tools/list':
-          result = await client.listTools();
-          break;
-        case 'tools/call':
-          if (!params?.name) {
-            return res.status(400).json({
-              error: 'Invalid request',
-              message: 'Tool name is required',
+      const { client } = await getClient(serverName, sessionId);
+
+      const executeMethod = async () => {
+        switch (method) {
+          case 'tools/list':
+            return await client.listTools();
+          case 'tools/call':
+            if (!params?.name) {
+              return res.status(400).json({
+                error: 'Invalid request',
+                message: 'Tool name is required',
+              });
+            }
+            return await client.callTool({
+              name: params.name,
+              arguments: params.arguments || {},
             });
-          }
-          result = await client.callTool({
-            name: params.name,
-            arguments: params.arguments || {},
-          });
-          break;
-        case 'prompts/list':
-          result = await client.listPrompts();
-          break;
-        case 'prompts/get':
-          if (!params?.name) {
-            return res.status(400).json({
-              error: 'Invalid request',
-              message: 'Prompt name is required',
+          case 'prompts/list':
+            return await client.listPrompts();
+          case 'prompts/get':
+            if (!params?.name) {
+              return res.status(400).json({
+                error: 'Invalid request',
+                message: 'Prompt name is required',
+              });
+            }
+            return await client.getPrompt({
+              name: params.name,
+              arguments: params.arguments || {},
             });
-          }
-          result = await client.getPrompt({
-            name: params.name,
-            arguments: params.arguments || {},
-          });
-          break;
-        case 'resources/list':
-          result = await client.listResources();
-          break;
-        case 'resources/read':
-          if (!params?.uri) {
+          case 'resources/list':
+            return await client.listResources();
+          case 'resources/read':
+            if (!params?.uri) {
+              return res.status(400).json({
+                error: 'Invalid request',
+                message: 'Resource URI is required',
+              });
+            }
+            return await client.readResource({ uri: params.uri });
+          default:
             return res.status(400).json({
-              error: 'Invalid request',
-              message: 'Resource URI is required',
+              error: 'Unsupported method',
+              message: `Method ${method} is not supported`,
             });
-          }
-          result = await client.readResource({ uri: params.uri });
-          break;
-        default:
-          return res.status(400).json({
-            error: 'Unsupported method',
-            message: `Method ${method} is not supported`,
-          });
-      }
+        }
+      };
+
+      const result = await executeMethod();
 
       // Return session ID in response
       res.setHeader('Mcp-Session-Id', sessionId);
@@ -119,7 +135,7 @@ export function createPlaygroundRoutes() {
         _sessionId: sessionId,
       });
     } catch (error) {
-      console.error('Error in playground proxy:', error);
+      logger.error({ error: error.message }, 'Error in playground proxy');
 
       // Check if it's a connection error
       if (error.message?.includes('ECONNREFUSED') || error.message?.includes('connect')) {
@@ -140,10 +156,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 });
   };

package/ui/server/routes/requests.js

@@ -1,22 +1,25 @@
-import { serializeBigInt } from '../utils/serialization.js';
 import { queryRequests } from 'mcp-shark-common/db/query.js';
+import logger from '../utils/logger.js';
+import { serializeBigInt } from '../utils/serialization.js';
+
+const sanitizeSearch = (value) => {
+  if (value !== undefined && value !== null) {
+    const trimmed = String(value).trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  return null;
+};
 
 export function createRequestsRoutes(db) {
   const router = {};
 
   router.getRequests = (req, res) => {
     try {
-      const limit = parseInt(req.query.limit) || 1000;
-      const offset = parseInt(req.query.offset) || 0;
+      const limit = Number.parseInt(req.query.limit) || 1000;
+      const offset = Number.parseInt(req.query.offset) || 0;
 
       // Sanitize search parameter - convert empty strings to null
-      let search = req.query.search;
-      if (search !== undefined && search !== null) {
-        search = String(search).trim();
-        search = search.length > 0 ? search : null;
-      } else {
-        search = null;
-      }
+      const search = sanitizeSearch(req.query.search);
 
       // Build filters object, ensuring all values are properly typed
       const filters = {
@@ -24,7 +27,7 @@ export function createRequestsRoutes(db) {
         direction: (req.query.direction && String(req.query.direction).trim()) || null,
         method: (req.query.method && String(req.query.method).trim()) || null,
         jsonrpcMethod: (req.query.jsonrpcMethod && String(req.query.jsonrpcMethod).trim()) || null,
-        statusCode: req.query.statusCode ? parseInt(req.query.statusCode) : null,
+        statusCode: req.query.statusCode ? Number.parseInt(req.query.statusCode) : null,
         jsonrpcId: (req.query.jsonrpcId && String(req.query.jsonrpcId).trim()) || null,
         search: search,
         serverName: (req.query.serverName && String(req.query.serverName).trim()) || null,
@@ -44,21 +47,21 @@ export function createRequestsRoutes(db) {
       const requests = queryRequests(db, filters);
       res.json(serializeBigInt(requests));
     } catch (error) {
-      console.error('Error in getRequests:', error);
+      logger.error({ error: error.message }, 'Error in getRequests');
       res.status(500).json({ error: 'Failed to query requests', details: error.message });
     }
   };
 
   router.getRequest = (req, res) => {
     const stmt = db.prepare('SELECT * FROM packets WHERE frame_number = ?');
-    const request = stmt.get(parseInt(req.params.frameNumber));
+    const request = stmt.get(Number.parseInt(req.params.frameNumber));
     if (!request) {
       return res.status(404).json({ error: 'Request not found' });
     }
     res.json(serializeBigInt(request));
   };
 
-  router.clearRequests = (req, res) => {
+  router.clearRequests = (_req, res) => {
     try {
       // Disable foreign key constraints temporarily to avoid constraint violations
       db.exec('PRAGMA foreign_keys = OFF');
@@ -87,19 +90,25 @@ export function createRequestsRoutes(db) {
       ];
 
       // Delete from each table that exists
-      let clearedCount = 0;
-      const clearedTables = [];
-      trafficTables.forEach((table) => {
-        if (existingTables.includes(table)) {
-          try {
-            db.exec(`DELETE FROM ${table}`);
-            clearedCount++;
-            clearedTables.push(table);
-          } catch (err) {
-            console.warn(`Error clearing table ${table}:`, err.message);
+      const clearResults = trafficTables.reduce(
+        (acc, table) => {
+          if (existingTables.includes(table)) {
+            try {
+              db.exec(`DELETE FROM ${table}`);
+              return {
+                count: acc.count + 1,
+                tables: [...acc.tables, table],
+              };
+            } catch (err) {
+              logger.warn({ table, error: err.message }, 'Error clearing table');
+            }
           }
-        }
-      });
+          return acc;
+        },
+        { count: 0, tables: [] }
+      );
+      const clearedCount = clearResults.count;
+      const clearedTables = clearResults.tables;
 
       // Re-enable foreign key constraints
       db.exec('PRAGMA foreign_keys = ON');
@@ -112,10 +121,10 @@ export function createRequestsRoutes(db) {
       // Make sure to re-enable foreign keys even if there's an error
       try {
         db.exec('PRAGMA foreign_keys = ON');
-      } catch (e) {
+      } catch (_e) {
         // Ignore
       }
-      console.error('Error clearing requests:', error);
+      logger.error({ error: error.message }, 'Error clearing requests');
       res.status(500).json({ error: 'Failed to clear traffic', details: error.message });
     }
   };
@@ -123,20 +132,14 @@ export function createRequestsRoutes(db) {
   router.exportRequests = (req, res) => {
     try {
       // Sanitize search parameter - convert empty strings to null
-      let search = req.query.search;
-      if (search !== undefined && search !== null) {
-        search = String(search).trim();
-        search = search.length > 0 ? search : null;
-      } else {
-        search = null;
-      }
+      const search = sanitizeSearch(req.query.search);
 
       const filters = {
         sessionId: req.query.sessionId || null,
         direction: req.query.direction || null,
         method: req.query.method || null,
         jsonrpcMethod: req.query.jsonrpcMethod || null,
-        statusCode: req.query.statusCode ? parseInt(req.query.statusCode) : null,
+        statusCode: req.query.statusCode ? Number.parseInt(req.query.statusCode) : null,
         jsonrpcId: req.query.jsonrpcId || null,
         search: search,
         serverName: req.query.serverName || null,
@@ -149,78 +152,79 @@ export function createRequestsRoutes(db) {
       const requests = queryRequests(db, filters);
       const format = req.query.format || 'json';
 
-      let content, contentType, extension;
-
-      if (format === 'csv') {
-        const headers = [
-          'Frame',
-          'Time',
-          'Source',
-          'Destination',
-          'Protocol',
-          'Length',
-          'Method',
-          'Status',
-          'JSON-RPC Method',
-          'Session ID',
-          'Server Name',
-        ];
-        const rows = requests.map((req) => [
-          req.frame_number || '',
-          req.timestamp_iso || '',
-          req.request?.host || '',
-          req.request?.host || '',
-          'HTTP',
-          req.length || '',
-          req.request?.method || '',
-          req.response?.status_code || '',
-          req.jsonrpc_method || '',
-          req.session_id || '',
-          req.server_name || '',
-        ]);
-
-        content = [
-          headers.join(','),
-          ...rows.map((row) =>
-            row.map((cell) => `"${String(cell).replace(/"/g, '""')}"`).join(',')
-          ),
-        ].join('\n');
-        contentType = 'text/csv';
-        extension = 'csv';
-      } else if (format === 'txt') {
-        content = requests
-          .map((req, idx) => {
-            const lines = [
-              `=== Request/Response #${idx + 1} (Frame ${req.frame_number || 'N/A'}) ===`,
-              `Time: ${req.timestamp_iso || 'N/A'}`,
-              `Session ID: ${req.session_id || 'N/A'}`,
-              `Server: ${req.server_name || 'N/A'}`,
-              `Direction: ${req.direction || 'N/A'}`,
-              `Method: ${req.request?.method || 'N/A'}`,
-              `Status: ${req.response?.status_code || 'N/A'}`,
-              `JSON-RPC Method: ${req.jsonrpc_method || 'N/A'}`,
-              `JSON-RPC ID: ${req.jsonrpc_id || 'N/A'}`,
-              `Length: ${req.length || 0} bytes`,
-              '',
-              'Request:',
-              JSON.stringify(req.request || {}, null, 2),
-              '',
-              'Response:',
-              JSON.stringify(req.response || {}, null, 2),
-              '',
-              '---',
-              '',
-            ];
-            return lines.join('\n');
-          })
-          .join('\n');
-        contentType = 'text/plain';
-        extension = 'txt';
-      } else {
-        content = JSON.stringify(serializeBigInt(requests), null, 2);
-        contentType = 'application/json';
-        extension = 'json';
-      }
+      const formatExport = (requests, format) => {
+        if (format === 'csv') {
+          const headers = [
+            'Frame',
+            'Time',
+            'Source',
+            'Destination',
+            'Protocol',
+            'Length',
+            'Method',
+            'Status',
+            'JSON-RPC Method',
+            'Session ID',
+            'Server Name',
+          ];
+          const rows = requests.map((req) => [
+            req.frame_number || '',
+            req.timestamp_iso || '',
+            req.request?.host || '',
+            req.request?.host || '',
+            'HTTP',
+            req.length || '',
+            req.request?.method || '',
+            req.response?.status_code || '',
+            req.jsonrpc_method || '',
+            req.session_id || '',
+            req.server_name || '',
+          ]);
+
+          const content = [
+            headers.join(','),
+            ...rows.map((row) =>
+              row.map((cell) => `"${String(cell).replace(/"/g, '""')}"`).join(',')
+            ),
+          ].join('\n');
+          return { content, contentType: 'text/csv', extension: 'csv' };
+        }
+
+        if (format === 'txt') {
+          const content = requests
+            .map((req, idx) => {
+              const lines = [
+                `=== Request/Response #${idx + 1} (Frame ${req.frame_number || 'N/A'}) ===`,
+                `Time: ${req.timestamp_iso || 'N/A'}`,
+                `Session ID: ${req.session_id || 'N/A'}`,
+                `Server: ${req.server_name || 'N/A'}`,
+                `Direction: ${req.direction || 'N/A'}`,
+                `Method: ${req.request?.method || 'N/A'}`,
+                `Status: ${req.response?.status_code || 'N/A'}`,
+                `JSON-RPC Method: ${req.jsonrpc_method || 'N/A'}`,
+                `JSON-RPC ID: ${req.jsonrpc_id || 'N/A'}`,
+                `Length: ${req.length || 0} bytes`,
+                '',
+                'Request:',
+                JSON.stringify(req.request || {}, null, 2),
+                '',
+                'Response:',
+                JSON.stringify(req.response || {}, null, 2),
+                '',
+                '---',
+                '',
+              ];
+              return lines.join('\n');
+            })
+            .join('\n');
+          return { content, contentType: 'text/plain', extension: 'txt' };
+        }
+
+        const content = JSON.stringify(serializeBigInt(requests), null, 2);
+        return { content, contentType: 'application/json', extension: 'json' };
+      };
+
+      const { content, contentType, extension } = formatExport(requests, format);
 
       const filename = `mcp-shark-traffic-${new Date().toISOString().replace(/[:.]/g, '-')}.${extension}`;
       res.setHeader('Content-Type', contentType);

package/ui/server/routes/sessions.js

@@ -1,12 +1,12 @@
+import { getSessionRequests, getSessions } from 'mcp-shark-common/db/query.js';
 import { serializeBigInt } from '../utils/serialization.js';
-import { getSessions, getSessionRequests } from 'mcp-shark-common/db/query.js';
 
 export function createSessionsRoutes(db) {
   const router = {};
 
   router.getSessions = (req, res) => {
-    const limit = parseInt(req.query.limit) || 1000;
-    const offset = parseInt(req.query.offset) || 0;
+    const limit = Number.parseInt(req.query.limit) || 1000;
+    const offset = Number.parseInt(req.query.offset) || 0;
     const filters = {
       startTime: req.query.startTime ? BigInt(req.query.startTime) : null,
       endTime: req.query.endTime ? BigInt(req.query.endTime) : null,
@@ -18,7 +18,7 @@ export function createSessionsRoutes(db) {
   };
 
   router.getSessionRequests = (req, res) => {
-    const limit = parseInt(req.query.limit) || 10000;
+    const limit = Number.parseInt(req.query.limit) || 10000;
     const requests = getSessionRequests(db, req.params.sessionId, limit);
     res.json(serializeBigInt(requests));
   };