@mcp-shark/mcp-shark 1.5.4 → 1.5.5

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

@@ -1,124 +0,0 @@
-const API_BASE_URL = 'https://smart.mcpshark.sh';
-import logger from '../../../utils/logger.js';
-import { computeMcpHash, getCachedScanResult, storeScanResult } from '../../../utils/scan-cache.js';
-
-/**
- * Create scan for multiple servers (one request per server)
- * POST /api/smartscan/scans/batch
- */
-export async function createBatchScans(req, res) {
-  try {
-    const { apiToken, servers } = req.body;
-
-    if (!apiToken) {
-      return res.status(400).json({
-        error: 'API token is required',
-      });
-    }
-
-    if (!servers || !Array.isArray(servers) || servers.length === 0) {
-      return res.status(400).json({
-        error: 'Servers array is required',
-      });
-    }
-
-    const scanPromises = servers.map(async (serverData) => {
-      const hash = computeMcpHash(serverData);
-      const cachedResult = getCachedScanResult(hash);
-      if (cachedResult) {
-        logger.info({ serverName: serverData.name }, 'Using cached scan result for server');
-        return {
-          serverName: serverData.name,
-          success: true,
-          status: 200,
-          data: cachedResult,
-          error: null,
-          cached: true,
-        };
-      }
-
-      const scanData = {
-        server: {
-          name: serverData.name || 'unknown',
-          description: serverData.description || null,
-        },
-        tools: (serverData.tools || []).map((tool) => {
-          const toolData = {
-            name: tool.name,
-            description: tool.description || null,
-          };
-          if (tool.inputSchema && typeof tool.inputSchema === 'object') {
-            toolData.input_schema = tool.inputSchema;
-          }
-          if (tool.outputSchema && typeof tool.outputSchema === 'object') {
-            toolData.output_schema = tool.outputSchema;
-          }
-          return toolData;
-        }),
-        resources: (serverData.resources || []).map((resource) => ({
-          uri: resource.uri,
-          name: resource.name || null,
-          description: resource.description || null,
-          mimeType: resource.mimeType || null,
-        })),
-        prompts: (serverData.prompts || []).map((prompt) => ({
-          name: prompt.name,
-          description: prompt.description || null,
-          arguments: prompt.arguments || [],
-        })),
-      };
-
-      try {
-        const response = await fetch(`${API_BASE_URL}/api/scans`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-            Authorization: `Bearer ${apiToken}`,
-          },
-          body: JSON.stringify(scanData),
-        });
-
-        const data = await response.json();
-
-        const result = {
-          serverName: serverData.name,
-          success: response.ok,
-          status: response.status,
-          data: response.ok ? data : null,
-          error: response.ok ? null : data.error || data.message || 'Unknown error',
-          cached: false,
-        };
-
-        if (response.ok && data) {
-          storeScanResult(serverData.name, hash, data);
-          logger.info({ serverName: serverData.name }, 'Stored scan result in cache for server');
-        }
-
-        return result;
-      } catch (error) {
-        return {
-          serverName: serverData.name,
-          success: false,
-          status: 500,
-          data: null,
-          error: error.message,
-          cached: false,
-        };
-      }
-    });
-
-    const results = await Promise.all(scanPromises);
-
-    return res.json({
-      success: true,
-      results,
-    });
-  } catch (error) {
-    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,43 +0,0 @@
-const API_BASE_URL = 'https://smart.mcpshark.sh';
-import logger from '../../../utils/logger.js';
-
-/**
- * Proxy POST request to create a scan
- * POST /api/smartscan/scans
- */
-export async function createScan(req, res) {
-  try {
-    const { apiToken, scanData } = req.body;
-
-    if (!apiToken) {
-      return res.status(400).json({
-        error: 'API token is required',
-      });
-    }
-
-    if (!scanData) {
-      return res.status(400).json({
-        error: 'Scan data is required',
-      });
-    }
-
-    const response = await fetch(`${API_BASE_URL}/api/scans`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-        Authorization: `Bearer ${apiToken}`,
-      },
-      body: JSON.stringify(scanData),
-    });
-
-    const data = await response.json();
-    return res.status(response.status).json(data);
-  } catch (error) {
-    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,52 +0,0 @@
-import logger from '../../../utils/logger.js';
-import { computeMcpHash, getCachedScanResult } from '../../../utils/scan-cache.js';
-
-/**
- * Get cached scan results for discovered servers
- * POST /api/smartscan/cached-results
- */
-export function getCachedResults(req, res) {
-  try {
-    const { servers } = req.body;
-
-    if (!servers || !Array.isArray(servers) || servers.length === 0) {
-      return res.status(400).json({
-        error: 'Servers array is required',
-      });
-    }
-
-    const cachedResults = servers.map((serverData) => {
-      const hash = computeMcpHash(serverData);
-      const cachedResult = getCachedScanResult(hash);
-
-      if (cachedResult) {
-        return {
-          serverName: serverData.name,
-          success: true,
-          data: cachedResult,
-          cached: true,
-          hash,
-        };
-      }
-
-      return {
-        serverName: serverData.name,
-        success: false,
-        data: null,
-        cached: false,
-        hash,
-      };
-    });
-
-    return res.json({
-      success: true,
-      results: cachedResults,
-    });
-  } catch (error) {
-    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,42 +0,0 @@
-const API_BASE_URL = 'https://smart.mcpshark.sh';
-import logger from '../../../utils/logger.js';
-
-/**
- * Proxy GET request to get a scan by ID
- * GET /api/smartscan/scans/:scanId
- */
-export async function getScan(req, res) {
-  try {
-    const { scanId } = req.params;
-    const apiToken = req.headers.authorization?.replace('Bearer ', '');
-
-    if (!apiToken) {
-      return res.status(401).json({
-        error: 'API token is required',
-      });
-    }
-
-    if (!scanId) {
-      return res.status(400).json({
-        error: 'Scan ID is required',
-      });
-    }
-
-    const response = await fetch(`${API_BASE_URL}/api/scans/${scanId}`, {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json',
-        Authorization: `Bearer ${apiToken}`,
-      },
-    });
-
-    const data = await response.json();
-    return res.status(response.status).json(data);
-  } catch (error) {
-    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,25 +0,0 @@
-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) {
-  try {
-    logger.info('Loading cached scans from local storage');
-    const cachedScans = getAllCachedScanResults();
-    logger.info({ count: cachedScans.length }, 'Returning cached scans');
-    return res.json({
-      scans: cachedScans,
-      cached: true,
-      count: cachedScans.length,
-    });
-  } catch (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,13 +0,0 @@
-import * as clearCacheRoute from './scans/clearCache.js';
-import * as createBatchScansRoute from './scans/createBatchScans.js';
-import * as createScanRoute from './scans/createScan.js';
-import * as getCachedResultsRoute from './scans/getCachedResults.js';
-import * as getScanRoute from './scans/getScan.js';
-import * as listScansRoute from './scans/listScans.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

@@ -1,57 +0,0 @@
-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) {
-  try {
-    const token = readSmartScanToken();
-    return res.json({
-      success: true,
-      token: token || null,
-    });
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error reading Smart Scan token');
-    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) {
-    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/utils/config-update.js

@@ -1,240 +0,0 @@
-import * as fs from 'node:fs';
-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);
-  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) {
-    logger.error({ error: error.message }, 'Error finding latest backup');
-    return null;
-  }
-}
-
-function shouldCreateBackup(
-  latestBackupPath,
-  resolvedFilePath,
-  content,
-  mcpSharkLogs,
-  broadcastLogUpdate
-) {
-  if (!latestBackupPath || !fs.existsSync(latestBackupPath)) {
-    return true;
-  }
-
-  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) {
-      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);
-      return false;
-    }
-    return true;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error comparing with latest backup');
-    // If comparison fails, create backup to be safe
-    return true;
-  }
-}
-
-function createBackup(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate) {
-  // Create backup with new format: .mcp.json-mcpshark.<datetime>.json
-  const datetimeStr = formatDateTimeForBackup();
-  const dir = path.dirname(resolvedFilePath);
-  const basename = path.basename(resolvedFilePath);
-  const backupPath = path.join(dir, `.${basename}-mcpshark.${datetimeStr}.json`);
-  fs.copyFileSync(resolvedFilePath, backupPath);
-  storeOriginalConfig(resolvedFilePath, content, backupPath);
-
-  const timestamp = new Date().toISOString();
-  const backupLog = {
-    timestamp,
-    type: 'stdout',
-    line: `[BACKUP] Created backup: ${backupPath.replace(homedir(), '~')}`,
-  };
-  mcpSharkLogs.push(backupLog);
-  if (mcpSharkLogs.length > 10000) {
-    mcpSharkLogs.shift();
-  }
-  broadcastLogUpdate(backupLog);
-  return backupPath;
-}
-
-function computeBackupPath(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate) {
-  if (!resolvedFilePath || !fs.existsSync(resolvedFilePath)) {
-    return null;
-  }
-
-  // Check if we need to create a backup by comparing with latest backup
-  const latestBackupPath = findLatestBackup(resolvedFilePath);
-  const needsBackup = shouldCreateBackup(
-    latestBackupPath,
-    resolvedFilePath,
-    content,
-    mcpSharkLogs,
-    broadcastLogUpdate
-  );
-
-  if (needsBackup) {
-    return createBackup(resolvedFilePath, content, mcpSharkLogs, broadcastLogUpdate);
-  }
-
-  // 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);
-  return null;
-}
-
-export function updateConfigFile(
-  originalConfig,
-  _selectedServiceNames,
-  resolvedFilePath,
-  content,
-  mcpSharkLogs,
-  broadcastLogUpdate
-) {
-  const [serverObject, serverType] = getServerObject(originalConfig);
-  const updatedConfig = { ...originalConfig };
-
-  if (serverObject) {
-    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]) => {
-      updatedServers[name] = {
-        type: 'http',
-        url: `http://localhost:9851/mcp/${encodeURIComponent(name)}`,
-      };
-    });
-    updatedConfig[serverType] = updatedServers;
-  }
-
-  const createdBackupPath = computeBackupPath(
-    resolvedFilePath,
-    content,
-    mcpSharkLogs,
-    broadcastLogUpdate
-  );
-
-  if (resolvedFilePath && fs.existsSync(resolvedFilePath)) {
-    fs.writeFileSync(resolvedFilePath, JSON.stringify(updatedConfig, null, 2));
-    logger.info({ path: resolvedFilePath }, 'Updated config file');
-  }
-
-  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;
-}
-
-function getServerObject(originalConfig) {
-  const hasMcpServers = originalConfig.mcpServers && typeof originalConfig.mcpServers === 'object';
-  const hasServers = originalConfig.servers && typeof originalConfig.servers === 'object';
-
-  if (hasMcpServers) {
-    return [originalConfig.mcpServers, 'mcpServers'];
-  }
-
-  if (hasServers) {
-    return [originalConfig.servers, 'servers'];
-  }
-
-  return [null, null];
-}
-
-export function formatDateTimeForBackup() {
-  const now = new Date();
-  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');
-  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
-}