@mcp-shark/mcp-shark 1.4.1 → 1.5.0

package/ui/server/utils/scan-cache/all-results.js

@@ -1,5 +1,6 @@
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import logger from '../logger.js';
 import { getScanResultsDirectory } from './directory.js';
 
 /**
@@ -9,13 +10,13 @@ import { getScanResultsDirectory } from './directory.js';
  * @returns {string} Server name
  */
 function extractServerName(data, scanData) {
-  let serverName = data.serverName; // From cache file metadata (most reliable)
+  const cachedServerName = data.serverName; // From cache file metadata (most reliable)
 
   // If not found at top level, try to extract from scan data (API response)
-  if (!serverName || serverName === 'Unknown Server') {
+  if (!cachedServerName || cachedServerName === 'Unknown Server') {
     const actualScanData = scanData.data || scanData;
 
-    serverName =
+    const serverName =
       actualScanData.serverName ||
       actualScanData.server_name ||
       actualScanData.server?.name ||
@@ -25,9 +26,11 @@ function extractServerName(data, scanData) {
       scanData.server?.name ||
       scanData.mcp_server_data?.server?.name ||
       'Unknown Server';
+
+    return serverName;
   }
 
-  return serverName;
+  return cachedServerName;
 }
 
 /**
@@ -39,25 +42,29 @@ function extractServerName(data, scanData) {
 function processScanFile(file, scanResultsDir) {
   try {
     const filePath = join(scanResultsDir, file);
-    console.log(`[getAllCachedScanResults] Reading file: ${file}`);
+    logger.debug({ file }, 'Reading cached scan result file');
 
     const fileContent = readFileSync(filePath, 'utf8');
     const data = JSON.parse(fileContent);
 
     // Validate that this is a scan result file
     if (!data || typeof data !== 'object') {
-      console.warn(`[getAllCachedScanResults] Invalid data in file ${file}: not an object`);
+      logger.warn({ file }, 'Invalid data in file: not an object');
       return null;
     }
 
     // Debug: Log the structure to understand what we're working with
-    console.log(`[getAllCachedScanResults] File ${file} structure:`, {
-      hasServerName: !!data.serverName,
-      serverName: data.serverName,
-      hasScanData: !!data.scanData,
-      scanDataKeys: data.scanData ? Object.keys(data.scanData) : [],
-      topLevelKeys: Object.keys(data),
-    });
+    logger.debug(
+      {
+        file,
+        hasServerName: !!data.serverName,
+        serverName: data.serverName,
+        hasScanData: !!data.scanData,
+        scanDataKeys: data.scanData ? Object.keys(data.scanData) : [],
+        topLevelKeys: Object.keys(data),
+      },
+      'File structure'
+    );
 
     // Create a scan-like object with id, server name, and scan data
     const scanData = data.scanData || data;
@@ -66,17 +73,16 @@ function processScanFile(file, scanResultsDir) {
 
     // Log if we couldn't find server name
     if (serverName === 'Unknown Server') {
-      console.warn(`[getAllCachedScanResults] Could not find server name in ${file}`);
-      console.warn(`[getAllCachedScanResults] data.serverName: ${data.serverName}`);
-      console.warn(`[getAllCachedScanResults] data keys: ${Object.keys(data || {}).join(', ')}`);
-      console.warn(
-        `[getAllCachedScanResults] scanData keys: ${Object.keys(scanData || {}).join(', ')}`
+      logger.warn(
+        {
+          file,
+          dataServerName: data.serverName,
+          dataKeys: Object.keys(data || {}).join(', '),
+          scanDataKeys: Object.keys(scanData || {}).join(', '),
+          scanDataDataKeys: scanData?.data ? Object.keys(scanData.data || {}).join(', ') : null,
+        },
+        'Could not find server name in file'
       );
-      if (scanData?.data) {
-        console.warn(
-          `[getAllCachedScanResults] scanData.data keys: ${Object.keys(scanData.data || {}).join(', ')}`
-        );
-      }
     }
 
     const scanResult = {
@@ -98,17 +104,18 @@ function processScanFile(file, scanResultsDir) {
       result: scanData,
     };
 
-    console.log(`[getAllCachedScanResults] Successfully loaded scan: ${serverName} (${scanId})`);
+    logger.debug({ serverName, scanId }, 'Successfully loaded scan');
     return scanResult;
   } catch (error) {
-    console.warn(
-      `[getAllCachedScanResults] Error reading scan result file ${file}:`,
-      error.message
+    logger.warn(
+      {
+        file,
+        filePath: join(scanResultsDir, file),
+        error: error.message,
+        stack: error.stack,
+      },
+      'Error reading scan result file'
     );
-    console.warn(`[getAllCachedScanResults] File path: ${join(scanResultsDir, file)}`);
-    if (error.stack) {
-      console.warn(`[getAllCachedScanResults] Stack: ${error.stack}`);
-    }
     return null;
   }
 }
@@ -120,46 +127,46 @@ function processScanFile(file, scanResultsDir) {
 export function getAllCachedScanResults() {
   try {
     const scanResultsDir = getScanResultsDirectory();
-    console.log('[getAllCachedScanResults] Reading cached scans from directory:', scanResultsDir);
+    logger.debug({ scanResultsDir }, 'Reading cached scans from directory');
 
     // Check if directory exists (don't create it, just check)
     if (!existsSync(scanResultsDir)) {
-      console.log(
-        '[getAllCachedScanResults] Scan results directory does not exist:',
-        scanResultsDir
-      );
+      logger.debug({ scanResultsDir }, 'Scan results directory does not exist');
       return [];
     }
 
     // Read all files in the directory
     const allFiles = readdirSync(scanResultsDir);
-    console.log(`[getAllCachedScanResults] Total files in directory: ${allFiles.length}`);
+    logger.debug({ count: allFiles.length }, 'Total files in directory');
 
     // Filter for JSON files only
     const jsonFiles = allFiles.filter((f) => f.endsWith('.json'));
-    console.log(
-      `[getAllCachedScanResults] Found ${jsonFiles.length} JSON files in ${scanResultsDir}`
-    );
+    logger.debug({ count: jsonFiles.length, scanResultsDir }, 'Found JSON files');
 
     if (jsonFiles.length === 0) {
-      console.log('[getAllCachedScanResults] No cached scan JSON files found');
+      logger.debug('No cached scan JSON files found');
       return [];
     }
 
-    const results = [];
-    let successCount = 0;
-    let errorCount = 0;
-
     // Read each file
-    for (const file of jsonFiles) {
-      const result = processScanFile(file, scanResultsDir);
-      if (result) {
-        results.push(result);
-        successCount++;
-      } else {
-        errorCount++;
-      }
-    }
+    const { results, successCount, errorCount } = jsonFiles.reduce(
+      (acc, file) => {
+        const result = processScanFile(file, scanResultsDir);
+        if (result) {
+          return {
+            results: [...acc.results, result],
+            successCount: acc.successCount + 1,
+            errorCount: acc.errorCount,
+          };
+        }
+        return {
+          results: acc.results,
+          successCount: acc.successCount,
+          errorCount: acc.errorCount + 1,
+        };
+      },
+      { results: [], successCount: 0, errorCount: 0 }
+    );
 
     // Sort by updatedAt descending (most recent first)
     results.sort((a, b) => {
@@ -168,13 +175,23 @@ export function getAllCachedScanResults() {
       return bTime - aTime;
     });
 
-    console.log(
-      `[getAllCachedScanResults] Summary: ${successCount} successful, ${errorCount} errors, ${results.length} total scans loaded`
+    logger.info(
+      {
+        successCount,
+        errorCount,
+        total: results.length,
+      },
+      'Summary: cached scans loaded'
     );
     return results;
   } catch (error) {
-    console.error('[getAllCachedScanResults] Fatal error getting all cached scan results:', error);
-    console.error('[getAllCachedScanResults] Error stack:', error.stack);
+    logger.error(
+      {
+        error: error.message,
+        stack: error.stack,
+      },
+      'Fatal error getting all cached scan results'
+    );
     return [];
   }
 }

package/ui/server/utils/scan-cache/directory.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
 

package/ui/server/utils/scan-cache/file-operations.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import logger from '../logger.js';
 import { getScanResultFilePath, getScanResultsDirectory } from './directory.js';
 
 /**
@@ -26,7 +27,7 @@ export function getCachedScanResult(hash) {
       serverName: data.serverName,
     };
   } catch (error) {
-    console.error('Error getting cached scan result:', error);
+    logger.error({ hash, error: error.message }, 'Error getting cached scan result');
     return null;
   }
 }
@@ -44,17 +45,19 @@ export function storeScanResult(serverName, hash, scanData) {
     const now = Date.now();
 
     // Check if file exists to preserve original creation time
-    let createdAt = now;
-    if (existsSync(filePath)) {
+    const getCreatedAt = (filePath, defaultTime) => {
+      if (!existsSync(filePath)) {
+        return defaultTime;
+      }
       try {
         const existingContent = readFileSync(filePath, 'utf8');
         const existingData = JSON.parse(existingContent);
-        createdAt = existingData.createdAt || now;
-      } catch (e) {
-        // If we can't read existing file, use current time
-        createdAt = now;
+        return existingData.createdAt || defaultTime;
+      } catch (_e) {
+        return defaultTime;
       }
-    }
+    };
+    const createdAt = getCreatedAt(filePath, now);
 
     const dataToStore = {
       serverName,
@@ -67,7 +70,7 @@ export function storeScanResult(serverName, hash, scanData) {
     writeFileSync(filePath, JSON.stringify(dataToStore, null, 2), 'utf8');
     return true;
   } catch (error) {
-    console.error('Error storing scan result:', error);
+    logger.error({ serverName, hash, error: error.message }, 'Error storing scan result');
     return false;
   }
 }
@@ -84,21 +87,21 @@ export function clearAllScanResults() {
     }
 
     const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
-    let deletedCount = 0;
 
-    for (const file of files) {
+    const deletedCount = files.reduce((count, file) => {
       try {
         const filePath = join(scanResultsDir, file);
         unlinkSync(filePath);
-        deletedCount++;
+        return count + 1;
       } catch (error) {
-        console.warn(`Error deleting scan result file ${file}:`, error);
+        logger.warn({ file, error: error.message }, 'Error deleting scan result file');
+        return count;
       }
-    }
+    }, 0);
 
     return deletedCount;
   } catch (error) {
-    console.error('Error clearing all scan results:', error);
+    logger.error({ error: error.message }, 'Error clearing all scan results');
     return 0;
   }
 }

package/ui/server/utils/scan-cache/server-operations.js

@@ -1,5 +1,6 @@
-import { readFileSync, existsSync, readdirSync, unlinkSync } from 'node:fs';
+import { readFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import logger from '../logger.js';
 import { ensureScanResultsDirectory } from './directory.js';
 
 /**
@@ -30,7 +31,7 @@ export function getCachedScanResultsForServer(serverName) {
         }
       } catch (error) {
         // Skip files that can't be parsed
-        console.warn(`Error reading scan result file ${file}:`, error);
+        logger.warn({ file, error: error.message }, 'Error reading scan result file');
       }
     }
 
@@ -39,7 +40,7 @@ export function getCachedScanResultsForServer(serverName) {
 
     return results;
   } catch (error) {
-    console.error('Error getting cached scan results for server:', error);
+    logger.error({ error: error.message }, 'Error getting cached scan results for server');
     return [];
   }
 }
@@ -54,9 +55,8 @@ export function clearOldScanResults(maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
     const scanResultsDir = ensureScanResultsDirectory();
     const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
     const cutoffTime = Date.now() - maxAgeMs;
-    let deletedCount = 0;
 
-    for (const file of files) {
+    const deletedCount = files.reduce((count, file) => {
       try {
         const filePath = join(scanResultsDir, file);
         const fileContent = readFileSync(filePath, 'utf8');
@@ -64,17 +64,22 @@ export function clearOldScanResults(maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
 
         if (data.updatedAt && data.updatedAt < cutoffTime) {
           unlinkSync(filePath);
-          deletedCount++;
+          return count + 1;
         }
+        return count;
       } catch (error) {
         // Skip files that can't be parsed
-        console.warn(`Error processing scan result file ${file} for cleanup:`, error);
+        logger.warn(
+          { file, error: error.message },
+          'Error processing scan result file for cleanup'
+        );
+        return count;
       }
-    }
+    }, 0);
 
     return deletedCount;
   } catch (error) {
-    console.error('Error clearing old scan results:', error);
+    logger.error({ error: error.message }, 'Error clearing old scan results');
     return 0;
   }
 }

package/ui/server/utils/serialization.js

@@ -1,7 +1,13 @@
 export function serializeBigInt(obj) {
-  if (obj === null || obj === undefined) return obj;
-  if (typeof obj === 'bigint') return obj.toString();
-  if (Array.isArray(obj)) return obj.map(serializeBigInt);
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+  if (typeof obj === 'bigint') {
+    return obj.toString();
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(serializeBigInt);
+  }
   if (typeof obj === 'object') {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {

package/ui/server/utils/smartscan-token.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { getWorkingDirectory, prepareAppDataSpaces } from 'mcp-shark-common/configs/index.js';
 import { join } from 'node:path';
+import { getWorkingDirectory, prepareAppDataSpaces } from 'mcp-shark-common/configs/index.js';
+import logger from './logger.js';
 
 const SMART_SCAN_TOKEN_NAME = 'smart-scan-token.json';
 
@@ -18,7 +19,7 @@ export function readSmartScanToken() {
     }
     return null;
   } catch (error) {
-    console.error('Error reading Smart Scan token:', error);
+    logger.error({ error: error.message }, 'Error reading Smart Scan token');
     return null;
   }
 }
@@ -36,7 +37,7 @@ export function writeSmartScanToken(token) {
     writeFileSync(tokenPath, JSON.stringify(data, null, 2), { mode: 0o600 }); // Read/write for owner only
     return true;
   } catch (error) {
-    console.error('Error writing Smart Scan token:', error);
+    logger.error({ error: error.message }, 'Error writing Smart Scan token');
     return false;
   }
 }

package/ui/server.js

@@ -1,34 +1,32 @@
+import { createServer } from 'node:http';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import express from 'express';
-import { createServer } from 'http';
 import { WebSocketServer } from 'ws';
-import * as path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'url';
 
+import { getDatabaseFile, prepareAppDataSpaces } from 'mcp-shark-common/configs/index.js';
 import { openDb } from 'mcp-shark-common/db/init.js';
-import {
-  getDatabaseFile,
-  prepareAppDataSpaces,
-  getMcpConfigPath,
-} from 'mcp-shark-common/configs/index.js';
 import { queryRequests } from 'mcp-shark-common/db/query.js';
 import { restoreOriginalConfig } from './server/utils/config.js';
 
-import { createRequestsRoutes } from './server/routes/requests.js';
-import { createConversationsRoutes } from './server/routes/conversations.js';
-import { createSessionsRoutes } from './server/routes/sessions.js';
-import { createStatisticsRoutes } from './server/routes/statistics.js';
-import { createLogsRoutes } from './server/routes/logs.js';
+import { createBackupRoutes } from './server/routes/backups/index.js';
+import { createCompositeRoutes } from './server/routes/composite/index.js';
 import { createConfigRoutes } from './server/routes/config.js';
-import { createBackupRoutes } from './server/routes/backups.js';
-import { createCompositeRoutes } from './server/routes/composite.js';
+import { createConversationsRoutes } from './server/routes/conversations.js';
 import { createHelpRoutes } from './server/routes/help.js';
+import { createLogsRoutes } from './server/routes/logs.js';
 import { createPlaygroundRoutes } from './server/routes/playground.js';
+import { createRequestsRoutes } from './server/routes/requests.js';
+import { createSessionsRoutes } from './server/routes/sessions.js';
+import { createSettingsRoutes } from './server/routes/settings.js';
 import { createSmartScanRoutes } from './server/routes/smartscan.js';
+import { createStatisticsRoutes } from './server/routes/statistics.js';
+import { serializeBigInt } from './server/utils/serialization.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const MAX_LOG_LINES = 10000;
+const _MAX_LOG_LINES = 10000;
 
 export function createUIServer() {
   prepareAppDataSpaces();
@@ -42,10 +40,10 @@ export function createUIServer() {
 
   const clients = new Set();
   const mcpSharkLogs = [];
-  const processState = { mcpSharkProcess: null };
+  const processState = { mcpSharkServer: null };
 
-  const setMcpSharkProcess = (process) => {
-    processState.mcpSharkProcess = process;
+  const setMcpSharkProcess = (server) => {
+    processState.mcpSharkServer = server;
   };
 
   wss.on('connection', (ws) => {
@@ -73,7 +71,7 @@ export function createUIServer() {
   const logsRoutes = createLogsRoutes(mcpSharkLogs, broadcastLogUpdate);
   const configRoutes = createConfigRoutes();
   const backupRoutes = createBackupRoutes();
-  const getMcpSharkProcess = () => processState.mcpSharkProcess;
+  const getMcpSharkProcess = () => processState.mcpSharkServer;
   const compositeRoutes = createCompositeRoutes(
     getMcpSharkProcess,
     setMcpSharkProcess,
@@ -83,6 +81,7 @@ export function createUIServer() {
   const helpRoutes = createHelpRoutes();
   const playgroundRoutes = createPlaygroundRoutes();
   const smartScanRoutes = createSmartScanRoutes();
+  const settingsRoutes = createSettingsRoutes();
 
   app.get('/api/requests', requestsRoutes.getRequests);
   app.get('/api/packets', requestsRoutes.getRequests);
@@ -120,6 +119,7 @@ export function createUIServer() {
     compositeRoutes.stop(req, res, restoreConfig);
   });
   app.get('/api/composite/status', compositeRoutes.getStatus);
+  app.get('/api/composite/servers', compositeRoutes.getServers);
 
   app.get('/api/help/state', helpRoutes.getState);
   app.post('/api/help/dismiss', helpRoutes.dismiss);
@@ -137,30 +137,17 @@ export function createUIServer() {
   app.post('/api/smartscan/cached-results', smartScanRoutes.getCachedResults);
   app.post('/api/smartscan/cache/clear', smartScanRoutes.clearCache);
 
-  const cleanup = () => {
-    if (processState.mcpSharkProcess) {
-      processState.mcpSharkProcess.kill();
-      processState.mcpSharkProcess = null;
-    }
-    restoreConfig();
-  };
-
-  process.on('SIGTERM', cleanup);
-  process.on('SIGINT', cleanup);
-  process.on('exit', () => {
-    restoreConfig();
-  });
+  app.get('/api/settings', settingsRoutes.getSettings);
 
   const staticPath = path.join(__dirname, 'dist');
   app.use(express.static(staticPath));
 
-  app.get('*', (req, res) => {
+  app.get('*', (_req, res) => {
     res.sendFile(path.join(staticPath, 'index.html'));
   });
 
   const notifyClients = async () => {
     const requests = queryRequests(db, { limit: 100 });
-    const { serializeBigInt } = await import('./server/utils/serialization.js');
     const message = JSON.stringify({ type: 'update', data: serializeBigInt(requests) });
     clients.forEach((client) => {
       if (client.readyState === 1) {
@@ -170,7 +157,7 @@ export function createUIServer() {
   };
 
   const timestampState = { lastTs: 0 };
-  setInterval(() => {
+  const intervalId = setInterval(() => {
     const lastCheck = db.prepare('SELECT MAX(timestamp_ns) as max_ts FROM packets').get();
     if (lastCheck && lastCheck.max_ts > timestampState.lastTs) {
       timestampState.lastTs = lastCheck.max_ts;
@@ -178,19 +165,78 @@ export function createUIServer() {
     }
   }, 500);
 
+  const cleanup = async () => {
+    console.log('Shutting down UI server...');
+
+    // Clear interval
+    clearInterval(intervalId);
+
+    // Stop MCP Shark server if running
+    if (processState.mcpSharkServer) {
+      try {
+        if (processState.mcpSharkServer.stop) {
+          await processState.mcpSharkServer.stop();
+        }
+        processState.mcpSharkServer = null;
+      } catch (err) {
+        console.error('Error stopping MCP Shark server:', err);
+      }
+    }
+
+    // Close WebSocket connections
+    clients.forEach((client) => {
+      if (client.readyState === 1) {
+        client.close();
+      }
+    });
+    clients.clear();
+
+    // Close WebSocket server
+    wss.close();
+
+    // Restore config
+    restoreConfig();
+
+    // Close HTTP server
+    return new Promise((resolve) => {
+      server.close(() => {
+        console.log('UI server stopped');
+        resolve();
+      });
+    });
+  };
+
   return { server, cleanup };
 }
 
 export async function runUIServer() {
-  const port = parseInt(process.env.UI_PORT) || 9853;
+  const port = Number.parseInt(process.env.UI_PORT) || 9853;
   const { server, cleanup } = createUIServer();
 
-  server.listen(port, '0.0.0.0', () => {
-    console.log(`UI server listening on http://localhost:${port}`);
+  const shutdown = async () => {
+    try {
+      await cleanup();
+    } catch (err) {
+      console.error('Error during shutdown:', err);
+    } finally {
+      process.exit(0);
+    }
+  };
+
+  // Register signal handlers
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+  process.on('exit', async () => {
+    // Final cleanup on exit
+    try {
+      await cleanup();
+    } catch (_err) {
+      // Ignore errors during exit
+    }
   });
 
-  server.on('close', () => {
-    cleanup();
+  server.listen(port, '0.0.0.0', () => {
+    console.log(`UI server listening on http://localhost:${port}`);
   });
 }
 

package/ui/src/App.jsx

@@ -1,16 +1,16 @@
 import { useEffect, useState } from 'react';
-import CompositeSetup from './CompositeSetup';
 import CompositeLogs from './CompositeLogs';
-import McpPlayground from './components/McpPlayground';
+import CompositeSetup from './CompositeSetup';
+import IntroTour from './IntroTour';
 import SmartScan from './SmartScan';
 import TabNavigation from './TabNavigation';
-import IntroTour from './IntroTour';
 import HelpButton from './components/App/HelpButton';
 import TrafficTab from './components/App/TrafficTab';
-import { colors } from './theme';
+import { useAppState } from './components/App/useAppState';
+import McpPlayground from './components/McpPlayground';
 import { tourSteps } from './config/tourSteps.jsx';
+import { colors } from './theme';
 import { fadeIn } from './utils/animations';
-import { useAppState } from './components/App/useAppState';
 
 function App() {
   const {