@mcp-shark/mcp-shark 1.4.0

package/ui/server/routes/requests.js

@@ -0,0 +1,235 @@
+import { serializeBigInt } from '../utils/serialization.js';
+import { queryRequests } from 'mcp-shark-common/db/query.js';
+
+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;
+
+      // 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;
+      }
+
+      // Build filters object, ensuring all values are properly typed
+      const filters = {
+        sessionId: (req.query.sessionId && String(req.query.sessionId).trim()) || null,
+        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,
+        jsonrpcId: (req.query.jsonrpcId && String(req.query.jsonrpcId).trim()) || null,
+        search: search,
+        serverName: (req.query.serverName && String(req.query.serverName).trim()) || null,
+        startTime: req.query.startTime ? BigInt(req.query.startTime) : null,
+        endTime: req.query.endTime ? BigInt(req.query.endTime) : null,
+        limit,
+        offset,
+      };
+
+      // Remove undefined values to avoid issues
+      Object.keys(filters).forEach((key) => {
+        if (filters[key] === undefined) {
+          filters[key] = null;
+        }
+      });
+
+      const requests = queryRequests(db, filters);
+      res.json(serializeBigInt(requests));
+    } catch (error) {
+      console.error('Error in getRequests:', error);
+      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));
+    if (!request) {
+      return res.status(404).json({ error: 'Request not found' });
+    }
+    res.json(serializeBigInt(request));
+  };
+
+  router.clearRequests = (req, res) => {
+    try {
+      // Disable foreign key constraints temporarily to avoid constraint violations
+      db.exec('PRAGMA foreign_keys = OFF');
+
+      // Get list of all tables in the database
+      const tablesResult = db
+        .prepare(
+          `
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+      `
+        )
+        .all();
+
+      const existingTables = tablesResult.map((row) => row.name);
+
+      // Based on mcp-shark-common schema, these are the traffic-related tables:
+      // - packets: Individual HTTP request/response packets
+      // - conversations: Correlated request/response pairs
+      // - sessions: Session tracking
+      // Clear in order to respect any foreign key dependencies
+      const trafficTables = [
+        'conversations', // Clear conversations first (may reference packets)
+        'packets', // Clear packets (main traffic data)
+        'sessions', // Clear sessions (may reference packets)
+      ];
+
+      // 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);
+          }
+        }
+      });
+
+      // Re-enable foreign key constraints
+      db.exec('PRAGMA foreign_keys = ON');
+
+      res.json({
+        success: true,
+        message: `Cleared ${clearedCount} table(s): ${clearedTables.join(', ')}. All captured traffic has been cleared.`,
+      });
+    } catch (error) {
+      // Make sure to re-enable foreign keys even if there's an error
+      try {
+        db.exec('PRAGMA foreign_keys = ON');
+      } catch (e) {
+        // Ignore
+      }
+      console.error('Error clearing requests:', error);
+      res.status(500).json({ error: 'Failed to clear traffic', details: error.message });
+    }
+  };
+
+  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 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,
+        jsonrpcId: req.query.jsonrpcId || null,
+        search: search,
+        serverName: req.query.serverName || null,
+        startTime: req.query.startTime ? BigInt(req.query.startTime) : null,
+        endTime: req.query.endTime ? BigInt(req.query.endTime) : null,
+        limit: 100000,
+        offset: 0,
+      };
+
+      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 filename = `mcp-shark-traffic-${new Date().toISOString().replace(/[:.]/g, '-')}.${extension}`;
+      res.setHeader('Content-Type', contentType);
+      res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+      res.send(content);
+    } catch (error) {
+      res.status(500).json({ error: 'Failed to export traffic', details: error.message });
+    }
+  };
+
+  return router;
+}

package/ui/server/routes/sessions.js

@@ -0,0 +1,27 @@
+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 filters = {
+      startTime: req.query.startTime ? BigInt(req.query.startTime) : null,
+      endTime: req.query.endTime ? BigInt(req.query.endTime) : null,
+      limit,
+      offset,
+    };
+    const sessions = getSessions(db, filters);
+    res.json(serializeBigInt(sessions));
+  };
+
+  router.getSessionRequests = (req, res) => {
+    const limit = parseInt(req.query.limit) || 10000;
+    const requests = getSessionRequests(db, req.params.sessionId, limit);
+    res.json(serializeBigInt(requests));
+  };
+
+  return router;
+}

package/ui/server/routes/smartscan/discover.js

@@ -0,0 +1,117 @@
+import { getMcpConfigPath } from 'mcp-shark-common/configs/index.js';
+import { readFileSync, existsSync } from 'node:fs';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { convertMcpServersToServers } from '../../utils/config.js';
+import { createTransport } from './transport.js';
+
+/**
+ * Discover a single MCP server
+ */
+async function discoverServer(serverName, serverConfig) {
+  const transport = createTransport(serverConfig, serverName);
+  const client = new Client(
+    { name: 'mcp-shark-smart-scan', version: '1.0.0' },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {},
+      },
+    }
+  );
+
+  try {
+    await client.connect(transport);
+
+    const [toolsResult, resourcesResult, promptsResult] = await Promise.allSettled([
+      client.listTools(),
+      client.listResources(),
+      client.listPrompts(),
+    ]);
+
+    const tools = toolsResult.status === 'fulfilled' ? toolsResult.value?.tools || [] : [];
+    const resources =
+      resourcesResult.status === 'fulfilled' ? resourcesResult.value?.resources || [] : [];
+    const prompts = promptsResult.status === 'fulfilled' ? promptsResult.value?.prompts || [] : [];
+
+    await client.close();
+    if (transport.close) {
+      await transport.close();
+    }
+
+    return {
+      name: serverName,
+      tools,
+      resources,
+      prompts,
+    };
+  } catch (error) {
+    try {
+      await client.close();
+      if (transport.close) {
+        await transport.close();
+      }
+    } catch (closeError) {
+      // Ignore close errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Discover all MCP servers from config
+ * GET /api/smartscan/discover
+ */
+export async function discoverServers(req, res) {
+  try {
+    const configPath = getMcpConfigPath();
+
+    if (!existsSync(configPath)) {
+      return res.status(404).json({
+        error: 'MCP config file not found',
+        message: `Config file not found at: ${configPath}`,
+      });
+    }
+
+    const configContent = readFileSync(configPath, 'utf-8');
+    const parsedConfig = JSON.parse(configContent);
+
+    const convertedConfig = convertMcpServersToServers(parsedConfig);
+    const servers = convertedConfig.servers || {};
+
+    if (Object.keys(servers).length === 0) {
+      return res.status(400).json({
+        error: 'No servers found in config',
+        message: 'The config file does not contain any MCP servers',
+      });
+    }
+
+    const discoveryPromises = Object.entries(servers).map(async ([serverName, serverConfig]) => {
+      try {
+        return await discoverServer(serverName, serverConfig);
+      } catch (error) {
+        console.error(`Error discovering server ${serverName}:`, error);
+        return {
+          name: serverName,
+          tools: [],
+          resources: [],
+          prompts: [],
+          error: error.message,
+        };
+      }
+    });
+
+    const discoveredServers = await Promise.all(discoveryPromises);
+
+    return res.json({
+      success: true,
+      servers: discoveredServers,
+    });
+  } catch (error) {
+    console.error('Error discovering servers:', error);
+    return res.status(500).json({
+      error: 'Failed to discover servers',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/clearCache.js

@@ -0,0 +1,22 @@
+import { clearAllScanResults } from '../../../utils/scan-cache.js';
+
+/**
+ * Clear all cached scan results
+ * POST /api/smartscan/cache/clear
+ */
+export function clearCache(req, res) {
+  try {
+    const deletedCount = clearAllScanResults();
+    return res.json({
+      success: true,
+      message: `Cleared ${deletedCount} cached scan result${deletedCount !== 1 ? 's' : ''}`,
+      deletedCount,
+    });
+  } catch (error) {
+    console.error('Error clearing cache:', error);
+    return res.status(500).json({
+      error: 'Failed to clear cache',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/createBatchScans.js

@@ -0,0 +1,123 @@
+const API_BASE_URL = 'https://smart.mcpshark.sh';
+import { computeMcpHash, getCachedScanResult, storeScanResult } from '../../../utils/scan-cache.js';
+
+/**
+ * Create scan for multiple servers (one request per server)
+ * POST /api/smartscan/scans/batch
+ */
+export async function createBatchScans(req, res) {
+  try {
+    const { apiToken, servers } = req.body;
+
+    if (!apiToken) {
+      return res.status(400).json({
+        error: 'API token is required',
+      });
+    }
+
+    if (!servers || !Array.isArray(servers) || servers.length === 0) {
+      return res.status(400).json({
+        error: 'Servers array is required',
+      });
+    }
+
+    const scanPromises = servers.map(async (serverData) => {
+      const hash = computeMcpHash(serverData);
+      const cachedResult = getCachedScanResult(hash);
+      if (cachedResult) {
+        console.log(`Using cached scan result for server: ${serverData.name}`);
+        return {
+          serverName: serverData.name,
+          success: true,
+          status: 200,
+          data: cachedResult,
+          error: null,
+          cached: true,
+        };
+      }
+
+      const scanData = {
+        server: {
+          name: serverData.name || 'unknown',
+          description: serverData.description || null,
+        },
+        tools: (serverData.tools || []).map((tool) => {
+          const toolData = {
+            name: tool.name,
+            description: tool.description || null,
+          };
+          if (tool.inputSchema && typeof tool.inputSchema === 'object') {
+            toolData.input_schema = tool.inputSchema;
+          }
+          if (tool.outputSchema && typeof tool.outputSchema === 'object') {
+            toolData.output_schema = tool.outputSchema;
+          }
+          return toolData;
+        }),
+        resources: (serverData.resources || []).map((resource) => ({
+          uri: resource.uri,
+          name: resource.name || null,
+          description: resource.description || null,
+          mimeType: resource.mimeType || null,
+        })),
+        prompts: (serverData.prompts || []).map((prompt) => ({
+          name: prompt.name,
+          description: prompt.description || null,
+          arguments: prompt.arguments || [],
+        })),
+      };
+
+      try {
+        const response = await fetch(`${API_BASE_URL}/api/scans`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            Authorization: `Bearer ${apiToken}`,
+          },
+          body: JSON.stringify(scanData),
+        });
+
+        const data = await response.json();
+
+        const result = {
+          serverName: serverData.name,
+          success: response.ok,
+          status: response.status,
+          data: response.ok ? data : null,
+          error: response.ok ? null : data.error || data.message || 'Unknown error',
+          cached: false,
+        };
+
+        if (response.ok && data) {
+          storeScanResult(serverData.name, hash, data);
+          console.log(`Stored scan result in cache for server: ${serverData.name}`);
+        }
+
+        return result;
+      } catch (error) {
+        return {
+          serverName: serverData.name,
+          success: false,
+          status: 500,
+          data: null,
+          error: error.message,
+          cached: false,
+        };
+      }
+    });
+
+    const results = await Promise.all(scanPromises);
+
+    return res.json({
+      success: true,
+      results,
+    });
+  } catch (error) {
+    console.error('Smart Scan batch API error:', error);
+    return res.status(500).json({
+      error: 'Failed to create batch scans',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/createScan.js

@@ -0,0 +1,42 @@
+const API_BASE_URL = 'https://smart.mcpshark.sh';
+
+/**
+ * Proxy POST request to create a scan
+ * POST /api/smartscan/scans
+ */
+export async function createScan(req, res) {
+  try {
+    const { apiToken, scanData } = req.body;
+
+    if (!apiToken) {
+      return res.status(400).json({
+        error: 'API token is required',
+      });
+    }
+
+    if (!scanData) {
+      return res.status(400).json({
+        error: 'Scan data is required',
+      });
+    }
+
+    const response = await fetch(`${API_BASE_URL}/api/scans`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiToken}`,
+      },
+      body: JSON.stringify(scanData),
+    });
+
+    const data = await response.json();
+    return res.status(response.status).json(data);
+  } catch (error) {
+    console.error('Smart Scan API error:', error);
+    return res.status(500).json({
+      error: 'Failed to create scan',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/getCachedResults.js

@@ -0,0 +1,51 @@
+import { computeMcpHash, getCachedScanResult } from '../../../utils/scan-cache.js';
+
+/**
+ * Get cached scan results for discovered servers
+ * POST /api/smartscan/cached-results
+ */
+export function getCachedResults(req, res) {
+  try {
+    const { servers } = req.body;
+
+    if (!servers || !Array.isArray(servers) || servers.length === 0) {
+      return res.status(400).json({
+        error: 'Servers array is required',
+      });
+    }
+
+    const cachedResults = servers.map((serverData) => {
+      const hash = computeMcpHash(serverData);
+      const cachedResult = getCachedScanResult(hash);
+
+      if (cachedResult) {
+        return {
+          serverName: serverData.name,
+          success: true,
+          data: cachedResult,
+          cached: true,
+          hash,
+        };
+      }
+
+      return {
+        serverName: serverData.name,
+        success: false,
+        data: null,
+        cached: false,
+        hash,
+      };
+    });
+
+    return res.json({
+      success: true,
+      results: cachedResults,
+    });
+  } catch (error) {
+    console.error('Error getting cached results:', error);
+    return res.status(500).json({
+      error: 'Failed to get cached results',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/getScan.js

@@ -0,0 +1,41 @@
+const API_BASE_URL = 'https://smart.mcpshark.sh';
+
+/**
+ * Proxy GET request to get a scan by ID
+ * GET /api/smartscan/scans/:scanId
+ */
+export async function getScan(req, res) {
+  try {
+    const { scanId } = req.params;
+    const apiToken = req.headers.authorization?.replace('Bearer ', '');
+
+    if (!apiToken) {
+      return res.status(401).json({
+        error: 'API token is required',
+      });
+    }
+
+    if (!scanId) {
+      return res.status(400).json({
+        error: 'Scan ID is required',
+      });
+    }
+
+    const response = await fetch(`${API_BASE_URL}/api/scans/${scanId}`, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiToken}`,
+      },
+    });
+
+    const data = await response.json();
+    return res.status(response.status).json(data);
+  } catch (error) {
+    console.error('Smart Scan API error:', error);
+    return res.status(500).json({
+      error: 'Failed to get scan',
+      message: error.message,
+    });
+  }
+}

package/ui/server/routes/smartscan/scans/listScans.js

@@ -0,0 +1,24 @@
+import { getAllCachedScanResults } from '../../../utils/scan-cache.js';
+
+/**
+ * List all scans from local cache only
+ * GET /api/smartscan/scans?cache=true
+ */
+export async function listScans(req, res) {
+  try {
+    console.log('[listScans] Loading cached scans from local storage...');
+    const cachedScans = getAllCachedScanResults();
+    console.log(`[listScans] Returning ${cachedScans.length} cached scans`);
+    return res.json({
+      scans: cachedScans,
+      cached: true,
+      count: cachedScans.length,
+    });
+  } catch (error) {
+    console.error('[listScans] Error loading cached scans:', error);
+    return res.status(500).json({
+      error: 'Failed to load cached scans',
+      message: error.message,
+    });
+  }
+}