@mcp-shark/mcp-shark 1.4.2 → 1.5.0

package/ui/server/routes/settings.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getDatabaseFile, getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
+import logger from '../utils/logger.js';
+import { getScanResultsDirectory } from '../utils/scan-cache/directory.js';
+
+const SMART_SCAN_TOKEN_NAME = 'smart-scan-token.json';
+
+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,
+      });
+    }
+  };
+
+  return router;
+}

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

@@ -1,7 +1,8 @@
-import { getMcpConfigPath } from 'mcp-shark-common/configs/index.js';
-import { readFileSync, existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { getMcpConfigPath } from 'mcp-shark-common/configs/index.js';
 import { convertMcpServersToServers } from '../../utils/config.js';
+import logger from '../../utils/logger.js';
 import { createTransport } from './transport.js';
 
 /**
@@ -51,7 +52,7 @@ async function discoverServer(serverName, serverConfig) {
       if (transport.close) {
         await transport.close();
       }
-    } catch (closeError) {
+    } catch (_closeError) {
       // Ignore close errors
     }
     throw error;
@@ -62,7 +63,7 @@ async function discoverServer(serverName, serverConfig) {
  * Discover all MCP servers from config
  * GET /api/smartscan/discover
  */
-export async function discoverServers(req, res) {
+export async function discoverServers(_req, res) {
   try {
     const configPath = getMcpConfigPath();
 
@@ -90,7 +91,7 @@ export async function discoverServers(req, res) {
       try {
         return await discoverServer(serverName, serverConfig);
       } catch (error) {
-        console.error(`Error discovering server ${serverName}:`, error);
+        logger.error({ serverName, error: error.message }, 'Error discovering server');
         return {
           name: serverName,
           tools: [],
@@ -108,7 +109,7 @@ export async function discoverServers(req, res) {
       servers: discoveredServers,
     });
   } catch (error) {
-    console.error('Error discovering servers:', error);
+    logger.error({ error: error.message }, 'Error discovering servers');
     return res.status(500).json({
       error: 'Failed to discover servers',
       message: error.message,

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

@@ -1,10 +1,11 @@
+import logger from '../../../utils/logger.js';
 import { clearAllScanResults } from '../../../utils/scan-cache.js';
 
 /**
  * Clear all cached scan results
  * POST /api/smartscan/cache/clear
  */
-export function clearCache(req, res) {
+export function clearCache(_req, res) {
   try {
     const deletedCount = clearAllScanResults();
     return res.json({
@@ -13,7 +14,7 @@ export function clearCache(req, res) {
       deletedCount,
     });
   } catch (error) {
-    console.error('Error clearing cache:', error);
+    logger.error({ error: error.message }, 'Error clearing cache');
     return res.status(500).json({
       error: 'Failed to clear cache',
       message: error.message,

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

@@ -1,4 +1,5 @@
 const API_BASE_URL = 'https://smart.mcpshark.sh';
+import logger from '../../../utils/logger.js';
 import { computeMcpHash, getCachedScanResult, storeScanResult } from '../../../utils/scan-cache.js';
 
 /**
@@ -25,7 +26,7 @@ export async function createBatchScans(req, res) {
       const hash = computeMcpHash(serverData);
       const cachedResult = getCachedScanResult(hash);
       if (cachedResult) {
-        console.log(`Using cached scan result for server: ${serverData.name}`);
+        logger.info({ serverName: serverData.name }, 'Using cached scan result for server');
         return {
           serverName: serverData.name,
           success: true,
@@ -91,7 +92,7 @@ export async function createBatchScans(req, res) {
 
         if (response.ok && data) {
           storeScanResult(serverData.name, hash, data);
-          console.log(`Stored scan result in cache for server: ${serverData.name}`);
+          logger.info({ serverName: serverData.name }, 'Stored scan result in cache for server');
         }
 
         return result;
@@ -114,7 +115,7 @@ export async function createBatchScans(req, res) {
       results,
     });
   } catch (error) {
-    console.error('Smart Scan batch API error:', error);
+    logger.error({ error: error.message }, 'Smart Scan batch API error');
     return res.status(500).json({
       error: 'Failed to create batch scans',
       message: error.message,

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

@@ -1,4 +1,5 @@
 const API_BASE_URL = 'https://smart.mcpshark.sh';
+import logger from '../../../utils/logger.js';
 
 /**
  * Proxy POST request to create a scan
@@ -33,7 +34,7 @@ export async function createScan(req, res) {
     const data = await response.json();
     return res.status(response.status).json(data);
   } catch (error) {
-    console.error('Smart Scan API error:', error);
+    logger.error({ error: error.message }, 'Smart Scan API error');
     return res.status(500).json({
       error: 'Failed to create scan',
       message: error.message,

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

@@ -1,3 +1,4 @@
+import logger from '../../../utils/logger.js';
 import { computeMcpHash, getCachedScanResult } from '../../../utils/scan-cache.js';
 
 /**
@@ -42,7 +43,7 @@ export function getCachedResults(req, res) {
       results: cachedResults,
     });
   } catch (error) {
-    console.error('Error getting cached results:', error);
+    logger.error({ error: error.message }, 'Error getting cached results');
     return res.status(500).json({
       error: 'Failed to get cached results',
       message: error.message,

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

@@ -1,4 +1,5 @@
 const API_BASE_URL = 'https://smart.mcpshark.sh';
+import logger from '../../../utils/logger.js';
 
 /**
  * Proxy GET request to get a scan by ID
@@ -32,7 +33,7 @@ export async function getScan(req, res) {
     const data = await response.json();
     return res.status(response.status).json(data);
   } catch (error) {
-    console.error('Smart Scan API error:', error);
+    logger.error({ error: error.message }, 'Smart Scan API error');
     return res.status(500).json({
       error: 'Failed to get scan',
       message: error.message,

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

@@ -1,21 +1,22 @@
+import logger from '../../../utils/logger.js';
 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) {
+export async function listScans(_req, res) {
   try {
-    console.log('[listScans] Loading cached scans from local storage...');
+    logger.info('Loading cached scans from local storage');
     const cachedScans = getAllCachedScanResults();
-    console.log(`[listScans] Returning ${cachedScans.length} cached scans`);
+    logger.info({ count: cachedScans.length }, 'Returning cached scans');
     return res.json({
       scans: cachedScans,
       cached: true,
       count: cachedScans.length,
     });
   } catch (error) {
-    console.error('[listScans] Error loading cached scans:', error);
+    logger.error({ error: error.message }, 'Error loading cached scans');
     return res.status(500).json({
       error: 'Failed to load cached scans',
       message: error.message,

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

@@ -1,9 +1,9 @@
+import * as clearCacheRoute from './scans/clearCache.js';
+import * as createBatchScansRoute from './scans/createBatchScans.js';
 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 getScanRoute from './scans/getScan.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;

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

@@ -1,10 +1,11 @@
+import logger from '../../utils/logger.js';
 import { readSmartScanToken, writeSmartScanToken } from '../../utils/smartscan-token.js';
 
 /**
  * Get stored Smart Scan token
  * GET /api/smartscan/token
  */
-export function getToken(req, res) {
+export function getToken(_req, res) {
   try {
     const token = readSmartScanToken();
     return res.json({
@@ -12,7 +13,7 @@ export function getToken(req, res) {
       token: token || null,
     });
   } catch (error) {
-    console.error('Error reading Smart Scan token:', error);
+    logger.error({ error: error.message }, 'Error reading Smart Scan token');
     return res.status(500).json({
       error: 'Failed to read token',
       message: error.message,
@@ -47,7 +48,7 @@ export function saveToken(req, res) {
       message: 'Token saved successfully',
     });
   } catch (error) {
-    console.error('Error saving Smart Scan token:', error);
+    logger.error({ error: error.message }, 'Error saving Smart Scan token');
     return res.status(500).json({
       error: 'Failed to save token',
       message: error.message,

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

@@ -1,6 +1,6 @@
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
 
 /**
  * Create transport for MCP server based on config

package/ui/server/routes/smartscan.js

@@ -3,9 +3,9 @@
  * 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';
+import * as tokenRoutes from './smartscan/token.js';
 
 export function createSmartScanRoutes() {
   const router = {};

package/ui/server/routes/statistics.js

@@ -1,5 +1,14 @@
-import { serializeBigInt } from '../utils/serialization.js';
 import { queryRequests } from 'mcp-shark-common/db/query.js';
+import logger from '../utils/logger.js';
+import { serializeBigInt } from '../utils/serialization.js';
+
+const sanitizeSearch = (value) => {
+  if (value !== undefined && value !== null) {
+    const trimmed = String(value).trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  return null;
+};
 
 export function createStatisticsRoutes(db) {
   const router = {};
@@ -7,13 +16,7 @@ export function createStatisticsRoutes(db) {
   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;
-      }
+      const search = sanitizeSearch(req.query.search);
 
       // Build filters object matching the requests route
       const filters = {
@@ -21,7 +24,7 @@ export function createStatisticsRoutes(db) {
         direction: (req.query.direction && String(req.query.direction).trim()) || null,
         method: (req.query.method && String(req.query.method).trim()) || null,
         jsonrpcMethod: (req.query.jsonrpcMethod && String(req.query.jsonrpcMethod).trim()) || null,
-        statusCode: req.query.statusCode ? parseInt(req.query.statusCode) : null,
+        statusCode: req.query.statusCode ? Number.parseInt(req.query.statusCode) : null,
         jsonrpcId: (req.query.jsonrpcId && String(req.query.jsonrpcId).trim()) || null,
         search: search,
         serverName: (req.query.serverName && String(req.query.serverName).trim()) || null,
@@ -74,7 +77,7 @@ export function createStatisticsRoutes(db) {
 
       res.json(serializeBigInt(stats));
     } catch (error) {
-      console.error('Error in getStatistics:', error);
+      logger.error({ error: error.message }, 'Error in getStatistics');
       res.status(500).json({ error: 'Failed to get statistics', details: error.message });
     }
   };

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

@@ -1,7 +1,8 @@
 import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { homedir } from 'node:os';
+import * as path from 'node:path';
 import { storeOriginalConfig } from './config.js';
+import logger from './logger.js';
 
 function findLatestBackup(filePath) {
   const dir = path.dirname(filePath);
@@ -51,7 +52,7 @@ function findLatestBackup(filePath) {
     backups.sort((a, b) => b.modifiedAt - a.modifiedAt);
     return backups[0].backupPath;
   } catch (error) {
-    console.error('Error finding latest backup:', error);
+    logger.error({ error: error.message }, 'Error finding latest backup');
     return null;
   }
 }
@@ -101,7 +102,7 @@ function shouldCreateBackup(
     }
     return true;
   } catch (error) {
-    console.error('Error comparing with latest backup:', error);
+    logger.error({ error: error.message }, 'Error comparing with latest backup');
     // If comparison fails, create backup to be safe
     return true;
   }
@@ -157,7 +158,7 @@ function computeBackupPath(resolvedFilePath, content, mcpSharkLogs, broadcastLog
 
 export function updateConfigFile(
   originalConfig,
-  selectedServiceNames,
+  _selectedServiceNames,
   resolvedFilePath,
   content,
   mcpSharkLogs,
@@ -170,7 +171,7 @@ export function updateConfigFile(
     const updatedServers = {};
     // Transform all original servers to HTTP URLs pointing to MCP shark server
     // Each server gets its own endpoint to avoid tool name prefixing issues
-    Object.entries(serverObject).forEach(([name, cfg]) => {
+    Object.entries(serverObject).forEach(([name, _cfg]) => {
       updatedServers[name] = {
         type: 'http',
         url: `http://localhost:9851/mcp/${encodeURIComponent(name)}`,
@@ -188,7 +189,7 @@ export function updateConfigFile(
 
   if (resolvedFilePath && fs.existsSync(resolvedFilePath)) {
     fs.writeFileSync(resolvedFilePath, JSON.stringify(updatedConfig, null, 2));
-    console.log(`Updated config file: ${resolvedFilePath}`);
+    logger.info({ path: resolvedFilePath }, 'Updated config file');
   }
 
   return { updatedConfig, backupPath: createdBackupPath };

package/ui/server/utils/config.js

@@ -1,5 +1,5 @@
 import * as fs from 'node:fs';
-import { homedir } from 'node:os';
+import logger from './logger.js';
 
 const state = { originalConfigData: null };
 
@@ -8,21 +8,21 @@ export function storeOriginalConfig(filePath, originalContent, backupPath) {
 }
 
 export function restoreOriginalConfig(mcpSharkLogs, broadcastLogUpdate) {
-  if (state.originalConfigData && state.originalConfigData.filePath) {
+  if (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}`);
+        logger.info({ path: state.originalConfigData.filePath }, 'Restored original config');
         state.originalConfigData = null;
         return true;
       }
       state.originalConfigData = null;
       return false;
     } catch (error) {
-      console.error('Failed to restore original config:', error);
+      logger.error({ error: error.message }, 'Failed to restore original config');
       const timestamp = new Date().toISOString();
       const errorLog = {
         timestamp,

package/ui/server/utils/logger.js

@@ -0,0 +1,2 @@
+// Re-export shared logger
+export { default } from '../../../shared/logger.js';