@mcp-shark/mcp-shark 1.5.4 → 1.5.5

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

@@ -1,197 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import logger from '../logger.js';
-import { getScanResultsDirectory } from './directory.js';
-
-/**
- * Extract server name from cached scan data
- * @param {Object} data - Cached file data
- * @param {Object} scanData - Scan data from API
- * @returns {string} Server name
- */
-function extractServerName(data, scanData) {
-  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 (!cachedServerName || cachedServerName === 'Unknown Server') {
-    const actualScanData = scanData.data || scanData;
-
-    const serverName =
-      actualScanData.serverName ||
-      actualScanData.server_name ||
-      actualScanData.server?.name ||
-      actualScanData.mcp_server_data?.server?.name ||
-      scanData.serverName ||
-      scanData.server_name ||
-      scanData.server?.name ||
-      scanData.mcp_server_data?.server?.name ||
-      'Unknown Server';
-
-    return serverName;
-  }
-
-  return cachedServerName;
-}
-
-/**
- * Process a single cached scan file
- * @param {string} file - File name
- * @param {string} scanResultsDir - Directory path
- * @returns {Object|null} Processed scan result or null if error
- */
-function processScanFile(file, scanResultsDir) {
-  try {
-    const filePath = join(scanResultsDir, 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') {
-      logger.warn({ file }, 'Invalid data in file: not an object');
-      return null;
-    }
-
-    // Debug: Log the structure to understand what we're working with
-    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;
-    const scanId = scanData.id || scanData.scan_id || data.hash || file.replace('.json', '');
-    const serverName = extractServerName(data, scanData);
-
-    // Log if we couldn't find server name
-    if (serverName === 'Unknown Server') {
-      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'
-      );
-    }
-
-    const scanResult = {
-      id: scanId,
-      scan_id: scanId,
-      server: {
-        name: serverName,
-      },
-      server_name: serverName,
-      serverName: serverName,
-      status: 'completed',
-      risk_level: scanData.overall_risk_level || scanData.risk_level || 'unknown',
-      overall_risk_level: scanData.overall_risk_level || scanData.risk_level || 'unknown',
-      created_at: data.createdAt || data.created_at || scanData.created_at,
-      updated_at: data.updatedAt || data.updated_at || scanData.updated_at,
-      cached: true,
-      hash: data.hash || file.replace('.json', ''),
-      data: scanData,
-      result: scanData,
-    };
-
-    logger.debug({ serverName, scanId }, 'Successfully loaded scan');
-    return scanResult;
-  } catch (error) {
-    logger.warn(
-      {
-        file,
-        filePath: join(scanResultsDir, file),
-        error: error.message,
-        stack: error.stack,
-      },
-      'Error reading scan result file'
-    );
-    return null;
-  }
-}
-
-/**
- * Get all cached scan results (across all servers)
- * @returns {Array} Array of cached scan results
- */
-export function getAllCachedScanResults() {
-  try {
-    const scanResultsDir = getScanResultsDirectory();
-    logger.debug({ scanResultsDir }, 'Reading cached scans from directory');
-
-    // Check if directory exists (don't create it, just check)
-    if (!existsSync(scanResultsDir)) {
-      logger.debug({ scanResultsDir }, 'Scan results directory does not exist');
-      return [];
-    }
-
-    // Read all files in the directory
-    const allFiles = readdirSync(scanResultsDir);
-    logger.debug({ count: allFiles.length }, 'Total files in directory');
-
-    // Filter for JSON files only
-    const jsonFiles = allFiles.filter((f) => f.endsWith('.json'));
-    logger.debug({ count: jsonFiles.length, scanResultsDir }, 'Found JSON files');
-
-    if (jsonFiles.length === 0) {
-      logger.debug('No cached scan JSON files found');
-      return [];
-    }
-
-    // Read each file
-    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) => {
-      const aTime = a.updated_at || a.created_at || 0;
-      const bTime = b.updated_at || b.created_at || 0;
-      return bTime - aTime;
-    });
-
-    logger.info(
-      {
-        successCount,
-        errorCount,
-        total: results.length,
-      },
-      'Summary: cached scans loaded'
-    );
-    return results;
-  } catch (error) {
-    logger.error(
-      {
-        error: error.message,
-        stack: error.stack,
-      },
-      'Fatal error getting all cached scan results'
-    );
-    return [];
-  }
-}

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

@@ -1,107 +0,0 @@
-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';
-
-/**
- * Get cached scan result by hash
- * @param {string} hash - SHA-256 hash of MCP server data
- * @returns {Object|null} Cached scan result or null if not found
- */
-export function getCachedScanResult(hash) {
-  try {
-    const filePath = getScanResultFilePath(hash);
-
-    if (!existsSync(filePath)) {
-      return null;
-    }
-
-    const fileContent = readFileSync(filePath, 'utf8');
-    const data = JSON.parse(fileContent);
-
-    return {
-      ...data.scanData,
-      cached: true,
-      cachedAt: data.createdAt,
-      updatedAt: data.updatedAt,
-      serverName: data.serverName,
-    };
-  } catch (error) {
-    logger.error({ hash, error: error.message }, 'Error getting cached scan result');
-    return null;
-  }
-}
-
-/**
- * Store scan result in cache
- * @param {string} serverName - Name of the MCP server
- * @param {string} hash - SHA-256 hash of MCP server data
- * @param {Object} scanData - Scan result data to store
- * @returns {boolean} Success status
- */
-export function storeScanResult(serverName, hash, scanData) {
-  try {
-    const filePath = getScanResultFilePath(hash);
-    const now = Date.now();
-
-    // Check if file exists to preserve original creation time
-    const getCreatedAt = (filePath, defaultTime) => {
-      if (!existsSync(filePath)) {
-        return defaultTime;
-      }
-      try {
-        const existingContent = readFileSync(filePath, 'utf8');
-        const existingData = JSON.parse(existingContent);
-        return existingData.createdAt || defaultTime;
-      } catch (_e) {
-        return defaultTime;
-      }
-    };
-    const createdAt = getCreatedAt(filePath, now);
-
-    const dataToStore = {
-      serverName,
-      hash,
-      scanData,
-      createdAt,
-      updatedAt: now,
-    };
-
-    writeFileSync(filePath, JSON.stringify(dataToStore, null, 2), 'utf8');
-    return true;
-  } catch (error) {
-    logger.error({ serverName, hash, error: error.message }, 'Error storing scan result');
-    return false;
-  }
-}
-
-/**
- * Clear all cached scan results
- * @returns {number} Number of files deleted
- */
-export function clearAllScanResults() {
-  try {
-    const scanResultsDir = getScanResultsDirectory();
-    if (!existsSync(scanResultsDir)) {
-      return 0;
-    }
-
-    const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
-
-    const deletedCount = files.reduce((count, file) => {
-      try {
-        const filePath = join(scanResultsDir, file);
-        unlinkSync(filePath);
-        return count + 1;
-      } catch (error) {
-        logger.warn({ file, error: error.message }, 'Error deleting scan result file');
-        return count;
-      }
-    }, 0);
-
-    return deletedCount;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error clearing all scan results');
-    return 0;
-  }
-}

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

@@ -1,47 +0,0 @@
-import { createHash } from 'node:crypto';
-
-/**
- * Compute SHA-256 hash of MCP server data for change detection
- * @param {Object} serverData - MCP server data (name, tools, resources, prompts)
- * @returns {string} SHA-256 hash in hex format
- */
-export function computeMcpHash(serverData) {
-  // Normalize the data to ensure consistent hashing
-  // Sort arrays to ensure order doesn't matter
-  const normalized = {
-    name: serverData.name || '',
-    tools: (serverData.tools || [])
-      .map((tool) => ({
-        name: tool.name || '',
-        description: tool.description || '',
-        inputSchema: tool.inputSchema || tool.input_schema || null,
-        outputSchema: tool.outputSchema || tool.output_schema || null,
-      }))
-      .sort((a, b) => (a.name || '').localeCompare(b.name || '')),
-    resources: (serverData.resources || [])
-      .map((resource) => ({
-        uri: resource.uri || '',
-        name: resource.name || '',
-        description: resource.description || '',
-        mimeType: resource.mimeType || resource.mime_type || null,
-      }))
-      .sort((a, b) => (a.uri || '').localeCompare(b.uri || '')),
-    prompts: (serverData.prompts || [])
-      .map((prompt) => ({
-        name: prompt.name || '',
-        description: prompt.description || '',
-        arguments: (prompt.arguments || []).sort((a, b) => {
-          const aName = (a.name || '').toString();
-          const bName = (b.name || '').toString();
-          return aName.localeCompare(bName);
-        }),
-      }))
-      .sort((a, b) => (a.name || '').localeCompare(b.name || '')),
-  };
-
-  // Create deterministic JSON string (sorted keys)
-  const jsonString = JSON.stringify(normalized);
-
-  // Compute SHA-256 hash
-  return createHash('sha256').update(jsonString).digest('hex');
-}

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

@@ -1,85 +0,0 @@
-import { readFileSync, readdirSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import logger from '../logger.js';
-import { ensureScanResultsDirectory } from './directory.js';
-
-/**
- * Get all cached scan results for a server
- * @param {string} serverName - Name of the MCP server
- * @returns {Array} Array of cached scan results
- */
-export function getCachedScanResultsForServer(serverName) {
-  try {
-    const scanResultsDir = ensureScanResultsDirectory();
-    const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
-    const results = [];
-
-    for (const file of files) {
-      try {
-        const filePath = join(scanResultsDir, file);
-        const fileContent = readFileSync(filePath, 'utf8');
-        const data = JSON.parse(fileContent);
-
-        if (data.serverName === serverName) {
-          results.push({
-            ...data.scanData,
-            cached: true,
-            cachedAt: data.createdAt,
-            updatedAt: data.updatedAt,
-            hash: data.hash,
-          });
-        }
-      } catch (error) {
-        // Skip files that can't be parsed
-        logger.warn({ file, error: error.message }, 'Error reading scan result file');
-      }
-    }
-
-    // Sort by updatedAt descending
-    results.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
-
-    return results;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error getting cached scan results for server');
-    return [];
-  }
-}
-
-/**
- * Clear old scan results (optional cleanup function)
- * @param {number} maxAgeMs - Maximum age in milliseconds (default: 30 days)
- * @returns {number} Number of files deleted
- */
-export function clearOldScanResults(maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
-  try {
-    const scanResultsDir = ensureScanResultsDirectory();
-    const files = readdirSync(scanResultsDir).filter((f) => f.endsWith('.json'));
-    const cutoffTime = Date.now() - maxAgeMs;
-
-    const deletedCount = files.reduce((count, file) => {
-      try {
-        const filePath = join(scanResultsDir, file);
-        const fileContent = readFileSync(filePath, 'utf8');
-        const data = JSON.parse(fileContent);
-
-        if (data.updatedAt && data.updatedAt < cutoffTime) {
-          unlinkSync(filePath);
-          return count + 1;
-        }
-        return count;
-      } catch (error) {
-        // Skip files that can't be parsed
-        logger.warn(
-          { file, error: error.message },
-          'Error processing scan result file for cleanup'
-        );
-        return count;
-      }
-    }, 0);
-
-    return deletedCount;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error clearing old scan results');
-    return 0;
-  }
-}

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

@@ -1,12 +0,0 @@
-// Main entry point - re-export all functions
-export { computeMcpHash } from './scan-cache/hash.js';
-export {
-  getCachedScanResult,
-  storeScanResult,
-  clearAllScanResults,
-} from './scan-cache/file-operations.js';
-export {
-  getCachedScanResultsForServer,
-  clearOldScanResults,
-} from './scan-cache/server-operations.js';
-export { getAllCachedScanResults } from './scan-cache/all-results.js';

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

@@ -1,43 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { getWorkingDirectory, prepareAppDataSpaces } from '#common/configs';
-import logger from './logger.js';
-
-const SMART_SCAN_TOKEN_NAME = 'smart-scan-token.json';
-
-function getSmartScanTokenPath() {
-  return join(getWorkingDirectory(), SMART_SCAN_TOKEN_NAME);
-}
-
-export function readSmartScanToken() {
-  try {
-    const tokenPath = getSmartScanTokenPath();
-    if (existsSync(tokenPath)) {
-      const content = readFileSync(tokenPath, 'utf8');
-      const data = JSON.parse(content);
-      return data.token || null;
-    }
-    return null;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error reading Smart Scan token');
-    return null;
-  }
-}
-
-export function writeSmartScanToken(token) {
-  try {
-    const tokenPath = getSmartScanTokenPath();
-    prepareAppDataSpaces(); // Ensure directory exists
-
-    const data = {
-      token: token || null,
-      updatedAt: new Date().toISOString(),
-    };
-
-    writeFileSync(tokenPath, JSON.stringify(data, null, 2), { mode: 0o600 }); // Read/write for owner only
-    return true;
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error writing Smart Scan token');
-    return false;
-  }
-}