@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/ui/server/routes/requests.js

@@ -1,239 +1,19 @@
-import { queryRequests } from '#common/db/query';
-import logger from '../utils/logger.js';
-import { serializeBigInt } from '../utils/serialization.js';
+import { RequestController } from '../controllers/RequestController.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(container) {
+  const requestService = container.getService('request');
+  const exportService = container.getService('export');
+  const serializationLib = container.getLibrary('serialization');
+  const logger = container.getLibrary('logger');
 
-export function createRequestsRoutes(db) {
-  const router = {};
-
-  router.getRequests = (req, res) => {
-    try {
-      const limit = Number.parseInt(req.query.limit) || 1000;
-      const offset = Number.parseInt(req.query.offset) || 0;
-
-      // Sanitize search parameter - convert empty strings to null
-      const search = sanitizeSearch(req.query.search);
-
-      // 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 ? 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,
-        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) {
-      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(Number.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 lib/common/db 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)
-      ];
+  const controller = new RequestController(requestService, exportService, serializationLib, logger);
 
-      // Delete from each table that exists
-      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');
-
-      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
-      }
-      logger.error({ error: error.message }, 'Error clearing requests');
-      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
-      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 ? Number.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';
-
-      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 router = {};
 
-      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 });
-    }
-  };
+  router.getRequests = (req, res) => controller.getRequests(req, res);
+  router.getRequest = (req, res) => controller.getRequest(req, res);
+  router.clearRequests = (req, res) => controller.clearRequests(req, res);
+  router.exportRequests = (req, res) => controller.exportRequests(req, res);
 
   return router;
 }

package/ui/server/routes/sessions.js

@@ -1,27 +1,16 @@
-import { getSessionRequests, getSessions } from '#common/db/query';
-import { serializeBigInt } from '../utils/serialization.js';
+import { SessionController } from '../controllers/SessionController.js';
 
-export function createSessionsRoutes(db) {
-  const router = {};
+export function createSessionsRoutes(container) {
+  const sessionService = container.getService('session');
+  const serializationLib = container.getLibrary('serialization');
+  const logger = container.getLibrary('logger');
+
+  const controller = new SessionController(sessionService, serializationLib, logger);
 
-  router.getSessions = (req, res) => {
-    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,
-      limit,
-      offset,
-    };
-    const sessions = getSessions(db, filters);
-    res.json(serializeBigInt(sessions));
-  };
+  const router = {};
 
-  router.getSessionRequests = (req, res) => {
-    const limit = Number.parseInt(req.query.limit) || 10000;
-    const requests = getSessionRequests(db, req.params.sessionId, limit);
-    res.json(serializeBigInt(requests));
-  };
+  router.getSessions = (req, res) => controller.getSessions(req, res);
+  router.getSessionRequests = (req, res) => controller.getSessionRequests(req, res);
 
   return router;
 }

package/ui/server/routes/settings.js

@@ -1,199 +1,17 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { getDatabaseFile, getWorkingDirectory } from '#common/configs';
-import logger from '../utils/logger.js';
-import { getScanResultsDirectory } from '../utils/scan-cache/directory.js';
+import { SettingsController } from '#ui/server/controllers/index.js';
 
-const SMART_SCAN_TOKEN_NAME = 'smart-scan-token.json';
+/**
+ * Create settings routes
+ * Routes delegate to SettingsController which calls SettingsService
+ */
+export function createSettingsRoutes(container) {
+  const settingsService = container.getService('settings');
+  const logger = container.getLibrary('logger');
+  const settingsController = new SettingsController(settingsService, logger);
 
-function getSmartScanTokenPath() {
-  return join(getWorkingDirectory(), SMART_SCAN_TOKEN_NAME);
-}
-
-function getTokenMetadata() {
-  try {
-    const tokenPath = getSmartScanTokenPath();
-    if (existsSync(tokenPath)) {
-      const content = readFileSync(tokenPath, 'utf8');
-      const data = JSON.parse(content);
-      const stats = statSync(tokenPath);
-      return {
-        token: data.token || null,
-        updatedAt: data.updatedAt || stats.mtime.toISOString(),
-        path: tokenPath,
-        exists: true,
-      };
-    }
-    return {
-      token: null,
-      updatedAt: null,
-      path: tokenPath,
-      exists: false,
-    };
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error reading Smart Scan token metadata');
-    return {
-      token: null,
-      updatedAt: null,
-      path: getSmartScanTokenPath(),
-      exists: false,
-    };
-  }
-}
-
-function getBackupCount() {
-  try {
-    const homeDir = homedir();
-    const backupDirs = [join(homeDir, '.cursor'), join(homeDir, '.codeium', 'windsurf')];
-
-    const newFormatCount = backupDirs.reduce((count, dir) => {
-      if (existsSync(dir)) {
-        const files = readdirSync(dir);
-        const matchingFiles = files.filter((file) => {
-          return /^\.(.+)-mcpshark\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.json$/.test(file);
-        });
-        return count + matchingFiles.length;
-      }
-      return count;
-    }, 0);
-
-    // Also count old .backup format
-    const commonPaths = [
-      join(homeDir, '.cursor', 'mcp.json'),
-      join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
-    ];
-    const oldFormatCount = commonPaths.reduce((count, configPath) => {
-      if (existsSync(`${configPath}.backup`)) {
-        return count + 1;
-      }
-      return count;
-    }, 0);
-
-    return newFormatCount + oldFormatCount;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error counting backups');
-    return 0;
-  }
-}
-
-function toDisplayPath(absolutePath) {
-  const homeDir = homedir();
-  return absolutePath.replace(homeDir, '~');
-}
-
-export function createSettingsRoutes() {
   const router = {};
 
-  router.getSettings = (_req, res) => {
-    try {
-      const homeDir = homedir();
-      const workingDir = getWorkingDirectory();
-      const databasePath = getDatabaseFile();
-      const scanResultsDir = getScanResultsDirectory();
-      const tokenPath = getSmartScanTokenPath();
-      const tokenMetadata = getTokenMetadata();
-
-      const cursorConfigPath = join(homeDir, '.cursor', 'mcp.json');
-      const windsurfConfigPath = join(homeDir, '.codeium', 'windsurf', 'mcp_config.json');
-
-      const cursorBackupDir = join(homeDir, '.cursor');
-      const windsurfBackupDir = join(homeDir, '.codeium', 'windsurf');
-
-      const settings = {
-        paths: {
-          workingDirectory: {
-            absolute: workingDir,
-            display: toDisplayPath(workingDir),
-            exists: existsSync(workingDir),
-          },
-          database: {
-            absolute: databasePath,
-            display: toDisplayPath(databasePath),
-            exists: existsSync(databasePath),
-          },
-          smartScanResults: {
-            absolute: scanResultsDir,
-            display: toDisplayPath(scanResultsDir),
-            exists: existsSync(scanResultsDir),
-          },
-          smartScanToken: {
-            absolute: tokenPath,
-            display: toDisplayPath(tokenPath),
-            exists: tokenMetadata.exists,
-          },
-          backupDirectories: {
-            cursor: {
-              absolute: cursorBackupDir,
-              display: toDisplayPath(cursorBackupDir),
-              exists: existsSync(cursorBackupDir),
-            },
-            windsurf: {
-              absolute: windsurfBackupDir,
-              display: toDisplayPath(windsurfBackupDir),
-              exists: existsSync(windsurfBackupDir),
-            },
-          },
-          configFiles: {
-            cursor: {
-              absolute: cursorConfigPath,
-              display: toDisplayPath(cursorConfigPath),
-              exists: existsSync(cursorConfigPath),
-            },
-            windsurf: {
-              absolute: windsurfConfigPath,
-              display: toDisplayPath(windsurfConfigPath),
-              exists: existsSync(windsurfConfigPath),
-            },
-          },
-        },
-        smartScan: {
-          token: tokenMetadata.token,
-          tokenPath: {
-            absolute: tokenMetadata.path,
-            display: toDisplayPath(tokenMetadata.path),
-          },
-          tokenUpdatedAt: tokenMetadata.updatedAt,
-          tokenExists: tokenMetadata.exists,
-        },
-        database: {
-          path: {
-            absolute: databasePath,
-            display: toDisplayPath(databasePath),
-          },
-          exists: existsSync(databasePath),
-        },
-        system: {
-          platform: process.platform,
-          homeDirectory: {
-            absolute: homeDir,
-            display: '~',
-          },
-        },
-        backups: {
-          directories: [
-            {
-              absolute: cursorBackupDir,
-              display: toDisplayPath(cursorBackupDir),
-            },
-            {
-              absolute: windsurfBackupDir,
-              display: toDisplayPath(windsurfBackupDir),
-            },
-          ],
-          count: getBackupCount(),
-        },
-      };
-
-      res.json(settings);
-    } catch (error) {
-      logger.error({ error: error.message }, 'Error getting settings');
-      res.status(500).json({
-        error: 'Failed to get settings',
-        details: error.message,
-      });
-    }
-  };
+  router.getSettings = settingsController.getSettings;
 
   return router;
 }

package/ui/server/routes/smartscan.js

@@ -1,24 +1,35 @@
+import {
+  McpDiscoveryController,
+  ScanController,
+  TokenController,
+} from '#ui/server/controllers/index.js';
+
 /**
- * Smart Scan API proxy routes
- * Proxies requests to the Smart Scan API to avoid CORS issues
+ * Create Smart Scan routes
+ * Routes delegate to controllers which call services
  */
+export function createSmartScanRoutes(container) {
+  const scanService = container.getService('scan');
+  const scanCacheService = container.getService('scanCache');
+  const mcpDiscoveryService = container.getService('mcpDiscovery');
+  const tokenService = container.getService('token');
+  const logger = container.getLibrary('logger');
 
-import * as discoverRoutes from './smartscan/discover.js';
-import * as scanRoutes from './smartscan/scans.js';
-import * as tokenRoutes from './smartscan/token.js';
+  const scanController = new ScanController(scanService, scanCacheService, logger);
+  const mcpDiscoveryController = new McpDiscoveryController(mcpDiscoveryService, logger);
+  const tokenController = new TokenController(tokenService, logger);
 
-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;
+  router.getToken = tokenController.getToken;
+  router.saveToken = tokenController.saveToken;
+  router.discoverServers = mcpDiscoveryController.discoverServers;
+  router.getCachedResults = scanController.getCachedResults;
+  router.createScan = scanController.createScan;
+  router.getScan = scanController.getScan;
+  router.listScans = scanController.listScans;
+  router.createBatchScans = scanController.createBatchScans;
+  router.clearCache = scanController.clearCache;
 
   return router;
 }

package/ui/server/routes/statistics.js

@@ -1,86 +1,15 @@
-import { queryRequests } from '#common/db/query';
-import logger from '../utils/logger.js';
-import { serializeBigInt } from '../utils/serialization.js';
+import { StatisticsController } from '../controllers/StatisticsController.js';
 
-const sanitizeSearch = (value) => {
-  if (value !== undefined && value !== null) {
-    const trimmed = String(value).trim();
-    return trimmed.length > 0 ? trimmed : null;
-  }
-  return null;
-};
+export function createStatisticsRoutes(container) {
+  const statisticsService = container.getService('statistics');
+  const serializationLib = container.getLibrary('serialization');
+  const logger = container.getLibrary('logger');
 
-export function createStatisticsRoutes(db) {
-  const router = {};
-
-  router.getStatistics = (req, res) => {
-    try {
-      // Sanitize search parameter - convert empty strings to null
-      const search = sanitizeSearch(req.query.search);
-
-      // 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 ? 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,
-        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;
-        }
-      });
+  const controller = new StatisticsController(statisticsService, serializationLib, logger);
 
-      // 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,
-      };
+  const router = {};
 
-      res.json(serializeBigInt(stats));
-    } catch (error) {
-      logger.error({ error: error.message }, 'Error in getStatistics');
-      res.status(500).json({ error: 'Failed to get statistics', details: error.message });
-    }
-  };
+  router.getStatistics = (req, res) => controller.getStatistics(req, res);
 
   return router;
 }