@mcp-shark/mcp-shark 1.5.4 → 1.5.5

package/core/services/McpDiscoveryService.js

@@ -0,0 +1,107 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { createTransport } from '#ui/server/routes/smartscan/transport.js';
+
+/**
+ * Service for MCP server discovery
+ * Handles discovering MCP servers and their capabilities
+ */
+export class McpDiscoveryService {
+  constructor(configService, logger) {
+    this.configService = configService;
+    this.logger = logger;
+  }
+
+  /**
+   * Discover a single MCP server
+   */
+  async discoverServer(serverName, serverConfig) {
+    const transport = createTransport(serverConfig, serverName);
+    const client = new Client(
+      { name: 'mcp-shark-smart-scan', version: '1.0.0' },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {},
+        },
+      }
+    );
+
+    try {
+      await client.connect(transport);
+
+      const [toolsResult, resourcesResult, promptsResult] = await Promise.allSettled([
+        client.listTools(),
+        client.listResources(),
+        client.listPrompts(),
+      ]);
+
+      const tools = toolsResult.status === 'fulfilled' ? toolsResult.value?.tools || [] : [];
+      const resources =
+        resourcesResult.status === 'fulfilled' ? resourcesResult.value?.resources || [] : [];
+      const prompts =
+        promptsResult.status === 'fulfilled' ? promptsResult.value?.prompts || [] : [];
+
+      await client.close();
+      if (transport.close) {
+        await transport.close();
+      }
+
+      return {
+        name: serverName,
+        tools,
+        resources,
+        prompts,
+      };
+    } catch (error) {
+      try {
+        await client.close();
+        if (transport.close) {
+          await transport.close();
+        }
+      } catch (_closeError) {
+        // Ignore close errors
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Discover all MCP servers from config
+   */
+  async discoverAllServers() {
+    const config = this.configService.readMcpConfig();
+    if (!config) {
+      return { success: false, error: 'MCP config file not found' };
+    }
+
+    const convertedConfig = this.configService.convertMcpServersToServers(config);
+    const servers = convertedConfig.servers || {};
+
+    if (Object.keys(servers).length === 0) {
+      return { success: false, error: 'No servers found in config' };
+    }
+
+    const discoveryPromises = Object.entries(servers).map(async ([serverName, serverConfig]) => {
+      try {
+        return await this.discoverServer(serverName, serverConfig);
+      } catch (error) {
+        this.logger?.error({ serverName, error: error.message }, 'Error discovering server');
+        return {
+          name: serverName,
+          tools: [],
+          resources: [],
+          prompts: [],
+          error: error.message,
+        };
+      }
+    });
+
+    const discoveredServers = await Promise.all(discoveryPromises);
+
+    return {
+      success: true,
+      servers: discoveredServers,
+    };
+  }
+}

package/core/services/RequestService.js

@@ -0,0 +1,56 @@
+import { Defaults } from '../constants/Defaults.js';
+/**
+ * Service for request-related business logic
+ * Uses repositories for data access
+ * HTTP-agnostic: accepts models, returns models
+ */
+import { RequestFilters } from '../models/RequestFilters.js';
+
+export class RequestService {
+  constructor(packetRepository) {
+    this.packetRepository = packetRepository;
+  }
+
+  /**
+   * Get requests with filters
+   * @param {RequestFilters} filters - Typed filter model
+   * @returns {Array} Array of packet objects (raw from repository)
+   */
+  getRequests(filters) {
+    const repoFilters = filters.toRepositoryFilters();
+    return this.packetRepository.queryRequests(repoFilters);
+  }
+
+  /**
+   * Get request by frame number
+   * @param {number} frameNumber - Frame number
+   * @returns {Object|null} Packet object or null if not found
+   */
+  getRequest(frameNumber) {
+    const parsedFrameNumber = Number.parseInt(frameNumber);
+    return this.packetRepository.getByFrameNumber(parsedFrameNumber);
+  }
+
+  /**
+   * Clear all requests
+   * @returns {Object} Result with clearedTables array
+   */
+  clearRequests() {
+    return this.packetRepository.clearAll();
+  }
+
+  /**
+   * Get requests for export (no limit)
+   * @param {RequestFilters} filters - Typed filter model
+   * @returns {Array} Array of packet objects
+   */
+  getRequestsForExport(filters) {
+    const exportFilters = new RequestFilters({
+      ...filters,
+      limit: Defaults.EXPORT_LIMIT,
+      offset: Defaults.DEFAULT_OFFSET,
+    });
+    const repoFilters = exportFilters.toRepositoryFilters();
+    return this.packetRepository.queryRequests(repoFilters);
+  }
+}

package/core/services/ScanCacheService.js

@@ -0,0 +1,242 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Defaults } from '#core/constants/Defaults.js';
+import {
+  ensureScanResultsDirectory,
+  getScanResultFilePath,
+  getScanResultsDirectory,
+} from '#core/utils/scan-cache/directory.js';
+
+/**
+ * Service for Smart Scan cache operations
+ * Handles caching, retrieval, and management of scan results
+ */
+export class ScanCacheService {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Compute SHA-256 hash of MCP server data
+   */
+  computeMcpHash(serverData) {
+    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 || '')),
+    };
+
+    const jsonString = JSON.stringify(normalized);
+    return createHash('sha256').update(jsonString).digest('hex');
+  }
+
+  /**
+   * Get cached scan result by hash
+   */
+  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) {
+      this.logger?.error({ hash, error: error.message }, 'Error getting cached scan result');
+      return null;
+    }
+  }
+
+  /**
+   * Get created timestamp from existing file or use default
+   */
+  _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;
+    }
+  }
+
+  /**
+   * Store scan result in cache
+   */
+  storeScanResult(serverName, hash, scanData) {
+    try {
+      const filePath = getScanResultFilePath(hash);
+      const now = Date.now();
+      const createdAt = this._getCreatedAt(filePath, now);
+
+      const dataToStore = {
+        serverName,
+        hash,
+        scanData,
+        createdAt,
+        updatedAt: now,
+      };
+
+      writeFileSync(filePath, JSON.stringify(dataToStore, null, 2), 'utf8');
+      return true;
+    } catch (error) {
+      this.logger?.error({ serverName, hash, error: error.message }, 'Error storing scan result');
+      return false;
+    }
+  }
+
+  /**
+   * Get all cached scan results
+   */
+  getAllCachedScanResults() {
+    try {
+      const scanResultsDir = getScanResultsDirectory();
+      if (!existsSync(scanResultsDir)) {
+        return [];
+      }
+
+      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);
+
+          const scanData = data.scanData || data;
+          const scanId = scanData.id || scanData.scan_id || data.hash || file.replace('.json', '');
+          const serverName = data.serverName || 'Unknown Server';
+
+          results.push({
+            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,
+          });
+        } catch (error) {
+          this.logger?.warn({ file, error: error.message }, 'Error reading scan result file');
+        }
+      }
+
+      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;
+      });
+
+      return results;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error getting all cached scan results');
+      return [];
+    }
+  }
+
+  /**
+   * Clear all cached scan results
+   */
+  clearAllScanResults() {
+    try {
+      const scanResultsDir = ensureScanResultsDirectory();
+      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) {
+          this.logger?.warn({ file, error: error.message }, 'Error deleting scan result file');
+          return count;
+        }
+      }, 0);
+
+      return deletedCount;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error clearing all scan results');
+      return 0;
+    }
+  }
+
+  /**
+   * Clear old scan results
+   */
+  clearOldScanResults(maxAgeMs = Defaults.SCAN_RESULTS_MAX_AGE_MS) {
+    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) {
+          this.logger?.warn({ file, error: error.message }, 'Error processing scan result file');
+          return count;
+        }
+      }, 0);
+
+      return deletedCount;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error clearing old scan results');
+      return 0;
+    }
+  }
+}

package/core/services/ScanService.js

@@ -0,0 +1,167 @@
+/**
+ * Service for Smart Scan API operations
+ * Handles communication with external Smart Scan API
+ */
+export class ScanService {
+  constructor(scanCacheService, logger) {
+    this.scanCacheService = scanCacheService;
+    this.logger = logger;
+    this.apiBaseUrl = 'https://smart.mcpshark.sh';
+  }
+
+  /**
+   * Create scan for a single server
+   */
+  async createScan(scanData, apiToken) {
+    const response = await fetch(`${this.apiBaseUrl}/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 {
+      success: response.ok,
+      status: response.status,
+      data: response.ok ? data : null,
+      error: response.ok ? null : data.error || data.message || 'Unknown error',
+    };
+  }
+
+  /**
+   * Create scans for multiple servers
+   */
+  async createBatchScans(servers, apiToken) {
+    const scanPromises = servers.map(async (serverData) => {
+      const hash = this.scanCacheService.computeMcpHash(serverData);
+      const cachedResult = this.scanCacheService.getCachedScanResult(hash);
+
+      if (cachedResult) {
+        this.logger?.info({ serverName: serverData.name }, 'Using cached scan result');
+        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 result = await this.createScan(scanData, apiToken);
+
+        const batchResult = {
+          serverName: serverData.name,
+          success: result.success,
+          status: result.status,
+          data: result.data,
+          error: result.error,
+          cached: false,
+        };
+
+        if (result.success && result.data) {
+          this.scanCacheService.storeScanResult(serverData.name, hash, result.data);
+          this.logger?.info({ serverName: serverData.name }, 'Stored scan result in cache');
+        }
+
+        return batchResult;
+      } catch (error) {
+        return {
+          serverName: serverData.name,
+          success: false,
+          status: 500,
+          data: null,
+          error: error.message,
+          cached: false,
+        };
+      }
+    });
+
+    return Promise.all(scanPromises);
+  }
+
+  /**
+   * Get scan by ID
+   */
+  async getScan(scanId, apiToken) {
+    const response = await fetch(`${this.apiBaseUrl}/api/scans/${scanId}`, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiToken}`,
+      },
+    });
+
+    const data = await response.json();
+    return {
+      success: response.ok,
+      status: response.status,
+      data: response.ok ? data : null,
+      error: response.ok ? null : data.error || data.message || 'Unknown error',
+    };
+  }
+
+  /**
+   * Get cached results for servers
+   */
+  getCachedResults(servers) {
+    return servers.map((serverData) => {
+      const hash = this.scanCacheService.computeMcpHash(serverData);
+      const cachedResult = this.scanCacheService.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,
+      };
+    });
+  }
+}