@mcp-shark/mcp-shark 1.4.0

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

@@ -0,0 +1,180 @@
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+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) {
+  let serverName = 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') {
+    const actualScanData = scanData.data || scanData;
+
+    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;
+}
+
+/**
+ * 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);
+    console.log(`[getAllCachedScanResults] Reading file: ${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`);
+      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),
+    });
+
+    // 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') {
+      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(', ')}`
+      );
+      if (scanData?.data) {
+        console.warn(
+          `[getAllCachedScanResults] scanData.data keys: ${Object.keys(scanData.data || {}).join(', ')}`
+        );
+      }
+    }
+
+    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,
+    };
+
+    console.log(`[getAllCachedScanResults] Successfully loaded scan: ${serverName} (${scanId})`);
+    return scanResult;
+  } catch (error) {
+    console.warn(
+      `[getAllCachedScanResults] Error reading scan result file ${file}:`,
+      error.message
+    );
+    console.warn(`[getAllCachedScanResults] File path: ${join(scanResultsDir, file)}`);
+    if (error.stack) {
+      console.warn(`[getAllCachedScanResults] Stack: ${error.stack}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get all cached scan results (across all servers)
+ * @returns {Array} Array of cached scan results
+ */
+export function getAllCachedScanResults() {
+  try {
+    const scanResultsDir = getScanResultsDirectory();
+    console.log('[getAllCachedScanResults] Reading cached scans from directory:', scanResultsDir);
+
+    // Check if directory exists (don't create it, just check)
+    if (!existsSync(scanResultsDir)) {
+      console.log(
+        '[getAllCachedScanResults] Scan results directory does not exist:',
+        scanResultsDir
+      );
+      return [];
+    }
+
+    // Read all files in the directory
+    const allFiles = readdirSync(scanResultsDir);
+    console.log(`[getAllCachedScanResults] Total files in directory: ${allFiles.length}`);
+
+    // Filter for JSON files only
+    const jsonFiles = allFiles.filter((f) => f.endsWith('.json'));
+    console.log(
+      `[getAllCachedScanResults] Found ${jsonFiles.length} JSON files in ${scanResultsDir}`
+    );
+
+    if (jsonFiles.length === 0) {
+      console.log('[getAllCachedScanResults] 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++;
+      }
+    }
+
+    // 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;
+    });
+
+    console.log(
+      `[getAllCachedScanResults] Summary: ${successCount} successful, ${errorCount} errors, ${results.length} total scans loaded`
+    );
+    return results;
+  } catch (error) {
+    console.error('[getAllCachedScanResults] Fatal error getting all cached scan results:', error);
+    console.error('[getAllCachedScanResults] Error stack:', error.stack);
+    return [];
+  }
+}

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

@@ -0,0 +1,35 @@
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getWorkingDirectory } from 'mcp-shark-common/configs/index.js';
+
+const SCAN_RESULTS_DIR_NAME = 'scan-results';
+
+/**
+ * Get the scan results directory path
+ * @returns {string} Path to scan results directory
+ */
+export function getScanResultsDirectory() {
+  return join(getWorkingDirectory(), SCAN_RESULTS_DIR_NAME);
+}
+
+/**
+ * Ensure the scan results directory exists
+ * @returns {string} Path to scan results directory
+ */
+export function ensureScanResultsDirectory() {
+  const scanResultsDir = getScanResultsDirectory();
+  if (!existsSync(scanResultsDir)) {
+    mkdirSync(scanResultsDir, { recursive: true });
+  }
+  return scanResultsDir;
+}
+
+/**
+ * Get file path for a scan result based on hash
+ * @param {string} hash - SHA-256 hash of MCP server data
+ * @returns {string} File path
+ */
+export function getScanResultFilePath(hash) {
+  ensureScanResultsDirectory();
+  return join(getScanResultsDirectory(), `${hash}.json`);
+}

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

@@ -0,0 +1,104 @@
+import { readFileSync, writeFileSync, existsSync, unlinkSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+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) {
+    console.error('Error getting cached scan result:', error);
+    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
+    let createdAt = now;
+    if (existsSync(filePath)) {
+      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;
+      }
+    }
+
+    const dataToStore = {
+      serverName,
+      hash,
+      scanData,
+      createdAt,
+      updatedAt: now,
+    };
+
+    writeFileSync(filePath, JSON.stringify(dataToStore, null, 2), 'utf8');
+    return true;
+  } catch (error) {
+    console.error('Error storing scan result:', error);
+    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'));
+    let deletedCount = 0;
+
+    for (const file of files) {
+      try {
+        const filePath = join(scanResultsDir, file);
+        unlinkSync(filePath);
+        deletedCount++;
+      } catch (error) {
+        console.warn(`Error deleting scan result file ${file}:`, error);
+      }
+    }
+
+    return deletedCount;
+  } catch (error) {
+    console.error('Error clearing all scan results:', error);
+    return 0;
+  }
+}

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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,80 @@
+import { readFileSync, existsSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+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
+        console.warn(`Error reading scan result file ${file}:`, error);
+      }
+    }
+
+    // Sort by updatedAt descending
+    results.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+
+    return results;
+  } catch (error) {
+    console.error('Error getting cached scan results for server:', error);
+    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;
+    let deletedCount = 0;
+
+    for (const file of files) {
+      try {
+        const filePath = join(scanResultsDir, file);
+        const fileContent = readFileSync(filePath, 'utf8');
+        const data = JSON.parse(fileContent);
+
+        if (data.updatedAt && data.updatedAt < cutoffTime) {
+          unlinkSync(filePath);
+          deletedCount++;
+        }
+      } catch (error) {
+        // Skip files that can't be parsed
+        console.warn(`Error processing scan result file ${file} for cleanup:`, error);
+      }
+    }
+
+    return deletedCount;
+  } catch (error) {
+    console.error('Error clearing old scan results:', error);
+    return 0;
+  }
+}

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

@@ -0,0 +1,12 @@
+// 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/serialization.js

@@ -0,0 +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 (typeof obj === 'object') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = serializeBigInt(value);
+    }
+    return result;
+  }
+  return obj;
+}

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

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { getWorkingDirectory, prepareAppDataSpaces } from 'mcp-shark-common/configs/index.js';
+import { join } from 'node:path';
+
+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) {
+    console.error('Error reading Smart Scan token:', error);
+    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) {
+    console.error('Error writing Smart Scan token:', error);
+    return false;
+  }
+}