@mcp-shark/mcp-shark 1.4.0

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

@@ -0,0 +1,13 @@
+import * as createScanRoute from './scans/createScan.js';
+import * as getScanRoute from './scans/getScan.js';
+import * as getCachedResultsRoute from './scans/getCachedResults.js';
+import * as createBatchScansRoute from './scans/createBatchScans.js';
+import * as listScansRoute from './scans/listScans.js';
+import * as clearCacheRoute from './scans/clearCache.js';
+
+export const createScan = createScanRoute.createScan;
+export const getScan = getScanRoute.getScan;
+export const getCachedResults = getCachedResultsRoute.getCachedResults;
+export const createBatchScans = createBatchScansRoute.createBatchScans;
+export const listScans = listScansRoute.listScans;
+export const clearCache = clearCacheRoute.clearCache;

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

@@ -0,0 +1,56 @@
+import { readSmartScanToken, writeSmartScanToken } from '../../utils/smartscan-token.js';
+
+/**
+ * Get stored Smart Scan token
+ * GET /api/smartscan/token
+ */
+export function getToken(req, res) {
+  try {
+    const token = readSmartScanToken();
+    return res.json({
+      success: true,
+      token: token || null,
+    });
+  } catch (error) {
+    console.error('Error reading Smart Scan token:', error);
+    return res.status(500).json({
+      error: 'Failed to read token',
+      message: error.message,
+    });
+  }
+}
+
+/**
+ * Save Smart Scan token
+ * POST /api/smartscan/token
+ */
+export function saveToken(req, res) {
+  try {
+    const { token } = req.body;
+
+    if (token === undefined) {
+      return res.status(400).json({
+        error: 'Token is required',
+      });
+    }
+
+    const success = writeSmartScanToken(token);
+
+    if (!success) {
+      return res.status(500).json({
+        error: 'Failed to save token',
+      });
+    }
+
+    return res.json({
+      success: true,
+      message: 'Token saved successfully',
+    });
+  } catch (error) {
+    console.error('Error saving Smart Scan token:', error);
+    return res.status(500).json({
+      error: 'Failed to save token',
+      message: error.message,
+    });
+  }
+}

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

@@ -0,0 +1,53 @@
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+/**
+ * Create transport for MCP server based on config
+ */
+export function createTransport(serverConfig, serverName) {
+  const type = serverConfig.type || (serverConfig.url ? 'http' : 'stdio');
+  const {
+    url,
+    headers: configHeaders = {},
+    command,
+    args = [],
+    env: configEnv = {},
+  } = serverConfig;
+
+  const env = {
+    ...process.env,
+    ...configEnv,
+  };
+
+  const requestInit = { headers: { ...configHeaders } };
+
+  switch (type) {
+    case 'stdio':
+      if (!command) {
+        throw new Error(`Server ${serverName}: command is required for stdio transport`);
+      }
+      return new StdioClientTransport({ command, args, env });
+
+    case 'http':
+    case 'sse':
+    case 'streamable-http':
+      if (!url) {
+        throw new Error(`Server ${serverName}: url is required for ${type} transport`);
+      }
+      return new StreamableHTTPClientTransport(new URL(url), { requestInit });
+
+    case 'ws':
+    case 'websocket':
+      if (!url) {
+        throw new Error(`Server ${serverName}: url is required for websocket transport`);
+      }
+      return new WebSocketClientTransport(new URL(url));
+
+    default:
+      if (command) {
+        return new StdioClientTransport({ command, args, env });
+      }
+      throw new Error(`Server ${serverName}: unsupported transport type: ${type}`);
+  }
+}

package/ui/server/routes/smartscan.js

@@ -0,0 +1,24 @@
+/**
+ * Smart Scan API proxy routes
+ * Proxies requests to the Smart Scan API to avoid CORS issues
+ */
+
+import * as tokenRoutes from './smartscan/token.js';
+import * as discoverRoutes from './smartscan/discover.js';
+import * as scanRoutes from './smartscan/scans.js';
+
+export function createSmartScanRoutes() {
+  const router = {};
+
+  router.getToken = tokenRoutes.getToken;
+  router.saveToken = tokenRoutes.saveToken;
+  router.discoverServers = discoverRoutes.discoverServers;
+  router.getCachedResults = scanRoutes.getCachedResults;
+  router.createScan = scanRoutes.createScan;
+  router.getScan = scanRoutes.getScan;
+  router.listScans = scanRoutes.listScans;
+  router.createBatchScans = scanRoutes.createBatchScans;
+  router.clearCache = scanRoutes.clearCache;
+
+  return router;
+}

package/ui/server/routes/statistics.js

@@ -0,0 +1,83 @@
+import { serializeBigInt } from '../utils/serialization.js';
+import { queryRequests } from 'mcp-shark-common/db/query.js';
+
+export function createStatisticsRoutes(db) {
+  const router = {};
+
+  router.getStatistics = (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;
+      }
+
+      // Build filters object matching the requests route
+      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: 1000000, // Large limit for accurate statistics
+        offset: 0,
+      };
+
+      // Remove undefined values to avoid issues
+      Object.keys(filters).forEach((key) => {
+        if (filters[key] === undefined) {
+          filters[key] = null;
+        }
+      });
+
+      // Get all filtered requests (no limit for accurate statistics)
+      const allRequests = queryRequests(db, filters);
+
+      // Calculate statistics from filtered requests
+      const totalPackets = allRequests.length;
+      const totalRequests = allRequests.filter((r) => r.direction === 'request').length;
+      const totalResponses = allRequests.filter((r) => r.direction === 'response').length;
+      const totalErrors = allRequests.filter((r) => {
+        if (r.direction === 'response') {
+          const statusCode = r.status_code || r.status;
+          return (
+            statusCode >= 400 ||
+            (r.body_json && typeof r.body_json === 'object' && r.body_json.error)
+          );
+        }
+        return false;
+      }).length;
+
+      // Get unique sessions
+      const uniqueSessions = new Set();
+      allRequests.forEach((r) => {
+        if (r.session_id) {
+          uniqueSessions.add(r.session_id);
+        }
+      });
+
+      const stats = {
+        total_packets: totalPackets,
+        total_requests: totalRequests,
+        total_responses: totalResponses,
+        total_errors: totalErrors,
+        unique_sessions: uniqueSessions.size,
+      };
+
+      res.json(serializeBigInt(stats));
+    } catch (error) {
+      console.error('Error in getStatistics:', error);
+      res.status(500).json({ error: 'Failed to get statistics', details: error.message });
+    }
+  };
+
+  return router;
+}

package/ui/server/utils/config-update.js

@@ -0,0 +1,212 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { storeOriginalConfig } from './config.js';
+
+function findLatestBackup(filePath) {
+  const dir = path.dirname(filePath);
+  const basename = path.basename(filePath);
+  const backups = [];
+
+  if (!fs.existsSync(dir)) {
+    return null;
+  }
+
+  try {
+    const files = fs.readdirSync(dir);
+
+    // Find backups with new format: .mcp.json-mcpshark.<datetime>.json
+    files
+      .filter((file) => {
+        // Match pattern: .<basename>-mcpshark.<datetime>.json
+        return /^\.(.+)-mcpshark\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.json$/.test(file);
+      })
+      .forEach((file) => {
+        const match = file.match(/^\.(.+)-mcpshark\./);
+        if (match && match[1] === basename) {
+          const backupPath = path.join(dir, file);
+          const stats = fs.statSync(backupPath);
+          backups.push({
+            backupPath,
+            modifiedAt: stats.mtime,
+          });
+        }
+      });
+
+    // Also check for old .backup format
+    const oldBackupPath = `${filePath}.backup`;
+    if (fs.existsSync(oldBackupPath)) {
+      const stats = fs.statSync(oldBackupPath);
+      backups.push({
+        backupPath: oldBackupPath,
+        modifiedAt: stats.mtime,
+      });
+    }
+
+    if (backups.length === 0) {
+      return null;
+    }
+
+    // Sort by modifiedAt (latest first) and return the latest
+    backups.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    return backups[0].backupPath;
+  } catch (error) {
+    console.error('Error finding latest backup:', error);
+    return null;
+  }
+}
+
+export function updateConfigFile(
+  originalConfig,
+  selectedServiceNames,
+  resolvedFilePath,
+  content,
+  mcpSharkLogs,
+  broadcastLogUpdate
+) {
+  const hasMcpServers = originalConfig.mcpServers && typeof originalConfig.mcpServers === 'object';
+  const hasServers = originalConfig.servers && typeof originalConfig.servers === 'object';
+
+  const updatedConfig = { ...originalConfig };
+
+  if (hasMcpServers) {
+    const updatedMcpServers = {};
+    if (selectedServiceNames.size > 0) {
+      updatedMcpServers['mcp-shark-server'] = {
+        type: 'http',
+        url: 'http://localhost:9851/mcp',
+      };
+    }
+    Object.entries(originalConfig.mcpServers).forEach(([name, cfg]) => {
+      if (!selectedServiceNames.has(name)) {
+        updatedMcpServers[name] = cfg;
+      }
+    });
+    updatedConfig.mcpServers = updatedMcpServers;
+  } else if (hasServers) {
+    const updatedServers = {};
+    if (selectedServiceNames.size > 0) {
+      updatedServers['mcp-shark-server'] = {
+        type: 'http',
+        url: 'http://localhost:9851/mcp',
+      };
+    }
+    Object.entries(originalConfig.servers).forEach(([name, cfg]) => {
+      if (!selectedServiceNames.has(name)) {
+        updatedServers[name] = cfg;
+      }
+    });
+    updatedConfig.servers = updatedServers;
+  } else {
+    updatedConfig.mcpServers = {
+      'mcp-shark-server': {
+        type: 'http',
+        url: 'http://localhost:9851/mcp',
+      },
+    };
+  }
+
+  let createdBackupPath = null;
+  if (resolvedFilePath && fs.existsSync(resolvedFilePath)) {
+    // Check if we need to create a backup by comparing with latest backup
+    const latestBackupPath = findLatestBackup(resolvedFilePath);
+    let shouldCreateBackup = true;
+
+    if (latestBackupPath && fs.existsSync(latestBackupPath)) {
+      try {
+        const latestBackupContent = fs.readFileSync(latestBackupPath, 'utf-8');
+        const currentContent = content || fs.readFileSync(resolvedFilePath, 'utf-8');
+
+        // Normalize both contents for comparison (remove whitespace differences)
+        const normalizeContent = (str) => {
+          try {
+            // Try to parse as JSON and re-stringify to normalize
+            return JSON.stringify(JSON.parse(str), null, 2);
+          } catch {
+            // If not valid JSON, just trim
+            return str.trim();
+          }
+        };
+
+        const normalizedBackup = normalizeContent(latestBackupContent);
+        const normalizedCurrent = normalizeContent(currentContent);
+
+        if (normalizedBackup === normalizedCurrent) {
+          shouldCreateBackup = false;
+          const timestamp = new Date().toISOString();
+          const skipLog = {
+            timestamp,
+            type: 'stdout',
+            line: `[BACKUP] Skipped backup (no changes detected): ${resolvedFilePath.replace(homedir(), '~')}`,
+          };
+          mcpSharkLogs.push(skipLog);
+          if (mcpSharkLogs.length > 10000) {
+            mcpSharkLogs.shift();
+          }
+          broadcastLogUpdate(skipLog);
+        }
+      } catch (error) {
+        console.error('Error comparing with latest backup:', error);
+        // If comparison fails, create backup to be safe
+        shouldCreateBackup = true;
+      }
+    }
+
+    if (shouldCreateBackup) {
+      // Create backup with new format: .mcp.json-mcpshark.<datetime>.json
+      const now = new Date();
+      // Format: YYYY-MM-DD_HH-MM-SS
+      const year = now.getFullYear();
+      const month = String(now.getMonth() + 1).padStart(2, '0');
+      const day = String(now.getDate()).padStart(2, '0');
+      const hours = String(now.getHours()).padStart(2, '0');
+      const minutes = String(now.getMinutes()).padStart(2, '0');
+      const seconds = String(now.getSeconds()).padStart(2, '0');
+      const datetimeStr = `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+      const dir = path.dirname(resolvedFilePath);
+      const basename = path.basename(resolvedFilePath);
+      createdBackupPath = path.join(dir, `.${basename}-mcpshark.${datetimeStr}.json`);
+      fs.copyFileSync(resolvedFilePath, createdBackupPath);
+      storeOriginalConfig(resolvedFilePath, content, createdBackupPath);
+
+      const timestamp = new Date().toISOString();
+      const backupLog = {
+        timestamp,
+        type: 'stdout',
+        line: `[BACKUP] Created backup: ${createdBackupPath.replace(homedir(), '~')}`,
+      };
+      mcpSharkLogs.push(backupLog);
+      if (mcpSharkLogs.length > 10000) {
+        mcpSharkLogs.shift();
+      }
+      broadcastLogUpdate(backupLog);
+    } else {
+      // Still store the original config reference even if we didn't create a new backup
+      // Use the latest backup path if available
+      storeOriginalConfig(resolvedFilePath, content, latestBackupPath);
+    }
+
+    fs.writeFileSync(resolvedFilePath, JSON.stringify(updatedConfig, null, 2));
+    console.log(`Updated config file: ${resolvedFilePath}`);
+  }
+
+  return { updatedConfig, backupPath: createdBackupPath };
+}
+
+export function getSelectedServiceNames(originalConfig, selectedServices) {
+  if (selectedServices && Array.isArray(selectedServices) && selectedServices.length > 0) {
+    return new Set(selectedServices);
+  }
+
+  const selectedServiceNames = new Set();
+  const hasMcpServers = originalConfig.mcpServers && typeof originalConfig.mcpServers === 'object';
+  const hasServers = originalConfig.servers && typeof originalConfig.servers === 'object';
+
+  if (hasMcpServers) {
+    Object.keys(originalConfig.mcpServers).forEach((name) => selectedServiceNames.add(name));
+  } else if (hasServers) {
+    Object.keys(originalConfig.servers).forEach((name) => selectedServiceNames.add(name));
+  }
+
+  return selectedServiceNames;
+}

package/ui/server/utils/config.js

@@ -0,0 +1,98 @@
+import * as fs from 'node:fs';
+import { homedir } from 'node:os';
+
+const state = { originalConfigData: null };
+
+export function storeOriginalConfig(filePath, originalContent, backupPath) {
+  state.originalConfigData = { filePath, originalContent, backupPath };
+}
+
+export function restoreOriginalConfig(mcpSharkLogs, broadcastLogUpdate) {
+  if (state.originalConfigData && state.originalConfigData.filePath) {
+    try {
+      if (fs.existsSync(state.originalConfigData.filePath)) {
+        fs.writeFileSync(
+          state.originalConfigData.filePath,
+          state.originalConfigData.originalContent
+        );
+        console.log(`Restored original config to: ${state.originalConfigData.filePath}`);
+        state.originalConfigData = null;
+        return true;
+      }
+      state.originalConfigData = null;
+      return false;
+    } catch (error) {
+      console.error('Failed to restore original config:', error);
+      const timestamp = new Date().toISOString();
+      const errorLog = {
+        timestamp,
+        type: 'error',
+        line: `[RESTORE ERROR] Failed to restore: ${error.message}`,
+      };
+      mcpSharkLogs.push(errorLog);
+      if (mcpSharkLogs.length > 10000) {
+        mcpSharkLogs.shift();
+      }
+      broadcastLogUpdate(errorLog);
+      return false;
+    }
+  }
+  return false;
+}
+
+export function clearOriginalConfig() {
+  state.originalConfigData = null;
+}
+
+export function convertMcpServersToServers(config) {
+  const { mcpServers, servers } = config;
+  const converted = { servers: {} };
+
+  if (servers) {
+    converted.servers = servers;
+  }
+
+  if (mcpServers) {
+    Object.entries(mcpServers).forEach(([name, cfg]) => {
+      const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+      converted.servers[name] = { type, ...cfg };
+    });
+  }
+
+  return converted;
+}
+
+export function extractServices(config) {
+  const { mcpServers, servers } = config;
+  const servicesMap = new Map();
+
+  if (servers) {
+    Object.entries(servers).forEach(([name, cfg]) => {
+      const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+      servicesMap.set(name, {
+        name,
+        type,
+        url: cfg.url || null,
+        command: cfg.command || null,
+        args: cfg.args || null,
+      });
+    });
+  }
+
+  if (mcpServers) {
+    Object.entries(mcpServers).forEach(([name, cfg]) => {
+      if (!servicesMap.has(name)) {
+        const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+        servicesMap.set(name, {
+          name,
+          type,
+          url: cfg.url || null,
+          command: cfg.command || null,
+          args: cfg.args || null,
+        });
+      }
+    });
+  }
+
+  return Array.from(servicesMap.values());
+}

package/ui/server/utils/paths.js

@@ -0,0 +1,23 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function findMcpServerPath() {
+  const pathsToCheck = [
+    path.join(process.cwd(), '../mcp-server'),
+    path.join(__dirname, '../../mcp-server'),
+    path.join(process.cwd(), 'mcp-server'),
+    path.join(__dirname, '../../mcp-server'),
+  ];
+
+  for (const possiblePath of pathsToCheck) {
+    if (fs.existsSync(possiblePath)) {
+      return possiblePath;
+    }
+  }
+
+  return path.join(process.cwd(), '../mcp-server');
+}

package/ui/server/utils/port.js

@@ -0,0 +1,28 @@
+import { createConnection } from 'net';
+
+export function checkPortReady(port, host = 'localhost', timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+
+    const tryConnect = () => {
+      const socket = createConnection(port, host);
+
+      socket.on('connect', () => {
+        socket.destroy();
+        resolve(true);
+      });
+
+      socket.on('error', (err) => {
+        socket.destroy();
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= timeout) {
+          reject(new Error(`Port ${port} not ready after ${timeout}ms`));
+        } else {
+          setTimeout(tryConnect, 200);
+        }
+      });
+    };
+
+    tryConnect();
+  });
+}

package/ui/server/utils/process.js

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+import * as path from 'node:path';
+import { findMcpServerPath } from './paths.js';
+import { enhancePath } from '../../paths.js';
+import { getMcpConfigPath, getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
+
+const MAX_LOG_LINES = 10000;
+
+export function createLogEntry(mcpSharkLogs, broadcastLogUpdate) {
+  return function logEntry(type, data) {
+    const timestamp = new Date().toISOString();
+    const line = data.toString();
+    mcpSharkLogs.push({ timestamp, type, line });
+    if (mcpSharkLogs.length > MAX_LOG_LINES) {
+      mcpSharkLogs.shift();
+    }
+    broadcastLogUpdate({ timestamp, type, line });
+  };
+}
+
+export function spawnMcpSharkServer(mcpSharkJsPath, mcpsJsonPath, logEntry) {
+  const mcpServerPath = findMcpServerPath();
+  const nodeExecutable = process.execPath || 'node';
+  const enhancedPath = enhancePath(process.env.PATH);
+
+  logEntry('info', `[UI Server] Spawning MCP-Shark server...`);
+  logEntry('info', `[UI Server] Executable: ${nodeExecutable}`);
+  logEntry('info', `[UI Server] Script: ${mcpSharkJsPath}`);
+  logEntry('info', `[UI Server] Config: ${mcpsJsonPath}`);
+  logEntry('info', `[UI Server] CWD: ${mcpServerPath}`);
+  logEntry('info', `[UI Server] Data dir: ${getWorkingDirectory()}`);
+  logEntry('info', `[UI Server] Enhanced PATH: ${enhancedPath}`);
+
+  const processHandle = spawn(nodeExecutable, [mcpSharkJsPath, mcpsJsonPath], {
+    cwd: mcpServerPath,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      PATH: enhancedPath,
+    },
+  });
+
+  console.log(`[UI Server] MCP-Shark process spawned with PID: ${processHandle.pid}`);
+
+  processHandle.stdout.on('data', (data) => {
+    logEntry('stdout', data);
+    process.stdout.write(data);
+  });
+
+  processHandle.stderr.on('data', (data) => {
+    logEntry('stderr', data);
+    process.stderr.write(data);
+  });
+
+  return processHandle;
+}
+
+export function setupProcessHandlers(processHandle, logEntry, onError, onExit) {
+  processHandle.on('error', (err) => {
+    console.error('Failed to start mcp-shark server:', err);
+    logEntry('error', `Failed to start mcp-shark server: ${err.message}`);
+    if (onError) onError(err);
+  });
+
+  processHandle.on('exit', (code, signal) => {
+    const message = `MCP Shark server process exited with code ${code}${signal ? ` (signal: ${signal})` : ''}`;
+    console.log(`[UI Server] ${message}`);
+    logEntry('exit', message);
+    if (code !== 0 && code !== null) {
+      console.error(`[UI Server] MCP-Shark process exited with non-zero code: ${code}`);
+      logEntry('error', `Process exited with code ${code}`);
+    }
+    if (onExit) onExit(code, signal);
+  });
+}
+
+export function getMcpSharkJsPath() {
+  const mcpServerPath = findMcpServerPath();
+  return path.join(mcpServerPath, 'mcp-shark.js');
+}