@mcp-shark/mcp-shark 1.5.4 → 1.5.5

package/core/services/ConfigTransformService.js

@@ -0,0 +1,178 @@
+/**
+ * Service for configuration transformations
+ * Handles converting, filtering, and updating config structures
+ */
+export class ConfigTransformService {
+  constructor(configParserFactory) {
+    this.parserFactory = configParserFactory;
+  }
+
+  /**
+   * Convert MCP servers format to servers format
+   * Normalizes config first, then converts mcpServers to servers
+   */
+  convertMcpServersToServers(config) {
+    // Normalize config to ensure consistent format
+    const normalized = this.parserFactory.normalizeToInternalFormat(config);
+    if (!normalized) {
+      return { servers: {} };
+    }
+
+    const converted = { servers: {} };
+
+    // Handle normalized servers (legacy format)
+    if (normalized.servers) {
+      converted.servers = { ...normalized.servers };
+    }
+
+    // Convert mcpServers to servers format
+    if (normalized.mcpServers) {
+      for (const [name, cfg] of Object.entries(normalized.mcpServers)) {
+        const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+        converted.servers[name] = { type, ...cfg };
+      }
+    }
+
+    return converted;
+  }
+
+  /**
+   * Extract services from config
+   */
+  extractServices(config) {
+    const { mcpServers, servers } = config;
+    const servicesMap = new Map();
+
+    if (servers) {
+      for (const [name, cfg] of Object.entries(servers)) {
+        const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+        servicesMap.set(name, {
+          name,
+          type,
+          url: cfg.url || null,
+          command: cfg.command || null,
+          args: cfg.args || null,
+        });
+      }
+    }
+
+    if (mcpServers) {
+      for (const [name, cfg] of Object.entries(mcpServers)) {
+        if (!servicesMap.has(name)) {
+          const type = cfg.type || (cfg.url ? 'http' : cfg.command ? 'stdio' : 'stdio');
+          servicesMap.set(name, {
+            name,
+            type,
+            url: cfg.url || null,
+            command: cfg.command || null,
+            args: cfg.args || null,
+          });
+        }
+      }
+    }
+
+    return Array.from(servicesMap.values());
+  }
+
+  /**
+   * Filter servers from config by selected service names
+   */
+  filterServers(config, selectedServices) {
+    if (!selectedServices || !Array.isArray(selectedServices) || selectedServices.length === 0) {
+      return config;
+    }
+
+    const filtered = { servers: {} };
+    for (const serviceName of selectedServices) {
+      if (config.servers?.[serviceName]) {
+        filtered.servers[serviceName] = config.servers[serviceName];
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Update config to use MCP Shark HTTP endpoints
+   */
+  updateConfigForMcpShark(originalConfig) {
+    const [serverObject, serverType] = this._getServerObject(originalConfig);
+    const updatedConfig = { ...originalConfig };
+
+    if (serverObject) {
+      const updatedServers = {};
+      for (const [name, _cfg] of Object.entries(serverObject)) {
+        updatedServers[name] = {
+          type: 'http',
+          url: `http://localhost:9851/mcp/${encodeURIComponent(name)}`,
+        };
+      }
+      updatedConfig[serverType] = updatedServers;
+    }
+
+    return updatedConfig;
+  }
+
+  /**
+   * Get selected service names from config
+   */
+  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) {
+      for (const name of Object.keys(originalConfig.mcpServers)) {
+        selectedServiceNames.add(name);
+      }
+    } else if (hasServers) {
+      for (const name of Object.keys(originalConfig.servers)) {
+        selectedServiceNames.add(name);
+      }
+    }
+
+    return selectedServiceNames;
+  }
+
+  /**
+   * Check if config file is patched by mcp-shark
+   * A patched config has servers with URLs pointing to localhost:9851/mcp/
+   */
+  isConfigPatched(config) {
+    if (!config || typeof config !== 'object') {
+      return false;
+    }
+
+    const servers = config.servers || config.mcpServers || {};
+    for (const [_name, cfg] of Object.entries(servers)) {
+      if (cfg && typeof cfg === 'object' && cfg.url) {
+        if (cfg.url.includes('localhost:9851/mcp/') || cfg.url.includes('127.0.0.1:9851/mcp/')) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  _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];
+  }
+}

package/core/services/ConversationService.js

@@ -0,0 +1,19 @@
+/**
+ * Service for conversation-related business logic
+ * HTTP-agnostic: accepts models, returns models
+ */
+export class ConversationService {
+  constructor(conversationRepository) {
+    this.conversationRepository = conversationRepository;
+  }
+
+  /**
+   * Get conversations with filters
+   * @param {ConversationFilters} filters - Typed filter model
+   * @returns {Array} Array of conversation objects (raw from repository)
+   */
+  getConversations(filters) {
+    const repoFilters = filters.toRepositoryFilters();
+    return this.conversationRepository.queryConversations(repoFilters);
+  }
+}

package/core/services/ExportService.js

@@ -0,0 +1,117 @@
+import { ExportFormat } from '../models/ExportFormat.js';
+
+/**
+ * Service for exporting data in various formats
+ * Handles formatting business logic for CSV, TXT, and JSON exports
+ */
+export class ExportService {
+  /**
+   * Format requests as CSV
+   * @param {Array} requests - Array of request objects
+   * @returns {{content: string, contentType: string, extension: string}}
+   */
+  formatAsCsv(requests) {
+    const headers = [
+      'Frame',
+      'Time',
+      'Source',
+      'Destination',
+      'Protocol',
+      'Length',
+      'Method',
+      'Status',
+      'JSON-RPC Method',
+      'Session ID',
+      'Server Name',
+    ];
+    const rows = requests.map((req) => [
+      req.frame_number || '',
+      req.timestamp_iso || '',
+      req.request?.host || '',
+      req.request?.host || '',
+      'HTTP',
+      req.length || '',
+      req.request?.method || '',
+      req.response?.status_code || '',
+      req.jsonrpc_method || '',
+      req.session_id || '',
+      req.server_name || '',
+    ]);
+
+    const content = [
+      headers.join(','),
+      ...rows.map((row) => row.map((cell) => `"${String(cell).replace(/"/g, '""')}"`).join(',')),
+    ].join('\n');
+
+    return { content, contentType: 'text/csv', extension: 'csv' };
+  }
+
+  /**
+   * Format requests as TXT
+   * @param {Array} requests - Array of request objects
+   * @returns {{content: string, contentType: string, extension: string}}
+   */
+  formatAsTxt(requests) {
+    const content = requests
+      .map((req, idx) => {
+        const lines = [
+          `=== Request/Response #${idx + 1} (Frame ${req.frame_number || 'N/A'}) ===`,
+          `Time: ${req.timestamp_iso || 'N/A'}`,
+          `Session ID: ${req.session_id || 'N/A'}`,
+          `Server: ${req.server_name || 'N/A'}`,
+          `Direction: ${req.direction || 'N/A'}`,
+          `Method: ${req.request?.method || 'N/A'}`,
+          `Status: ${req.response?.status_code || 'N/A'}`,
+          `JSON-RPC Method: ${req.jsonrpc_method || 'N/A'}`,
+          `JSON-RPC ID: ${req.jsonrpc_id || 'N/A'}`,
+          `Length: ${req.length || 0} bytes`,
+          '',
+          'Request:',
+          JSON.stringify(req.request || {}, null, 2),
+          '',
+          'Response:',
+          JSON.stringify(req.response || {}, null, 2),
+          '',
+          '---',
+          '',
+        ];
+        return lines.join('\n');
+      })
+      .join('\n');
+
+    return { content, contentType: 'text/plain', extension: 'txt' };
+  }
+
+  /**
+   * Format requests as JSON
+   * @param {Array} requests - Array of request objects
+   * @param {Object} serializationLib - Serialization library for BigInt handling
+   * @returns {{content: string, contentType: string, extension: string}}
+   */
+  formatAsJson(requests, serializationLib) {
+    const serialized = serializationLib.serializeBigInt(requests);
+    return {
+      content: JSON.stringify(serialized, null, 2),
+      contentType: 'application/json',
+      extension: 'json',
+    };
+  }
+
+  /**
+   * Export requests in the specified format
+   * @param {Array} requests - Array of request objects
+   * @param {string} format - Export format (csv, txt, json)
+   * @param {Object} serializationLib - Serialization library for BigInt handling (required for JSON)
+   * @returns {{content: string, contentType: string, extension: string}}
+   */
+  exportRequests(requests, format, serializationLib) {
+    if (format === ExportFormat.CSV) {
+      return this.formatAsCsv(requests);
+    }
+    if (format === ExportFormat.TXT) {
+      return this.formatAsTxt(requests);
+    }
+    // Default to JSON
+    return this.formatAsJson(requests, serializationLib);
+  }
+}

package/core/services/LogService.js

@@ -0,0 +1,64 @@
+import { Defaults } from '#core/constants/Defaults.js';
+
+/**
+ * Service for log management
+ * Handles log storage, retrieval, and export
+ */
+export class LogService {
+  constructor(logger) {
+    this.logger = logger;
+    this.logs = [];
+  }
+
+  /**
+   * Initialize with log array (for compatibility with existing code)
+   */
+  initialize(logsArray) {
+    this.logs = logsArray;
+  }
+
+  /**
+   * Get logs with filters
+   */
+  getLogs(filters = {}) {
+    const { limit = Defaults.DEFAULT_LIMIT, offset = 0 } = filters;
+    return [...this.logs].reverse().slice(offset, offset + limit);
+  }
+
+  /**
+   * Clear all logs
+   */
+  clearLogs() {
+    this.logs.length = 0;
+    return { success: true, message: 'Logs cleared' };
+  }
+
+  /**
+   * Export logs in text format
+   */
+  exportLogs() {
+    const logsText = this.logs
+      .map((log) => `[${log.timestamp}] [${log.type.toUpperCase()}] ${log.line}`)
+      .join('\n');
+
+    return logsText;
+  }
+
+  /**
+   * Add log entry
+   */
+  addLog(logEntry) {
+    this.logs.push(logEntry);
+    if (this.logs.length > Defaults.MAX_LOG_LINES) {
+      this.logs.shift();
+    }
+    return logEntry;
+  }
+
+  /**
+   * Get all logs (for internal use)
+   */
+  getAllLogs() {
+    return this.logs;
+  }
+}

package/core/services/McpClientService.js

@@ -0,0 +1,235 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Server as ServerConstants } from '#core/constants/Server.js';
+import { ValidationError } from '#core/libraries/index.js';
+
+/**
+ * Service for MCP client management (Playground)
+ * Handles client connections and method execution
+ */
+export class McpClientService {
+  constructor(logger) {
+    this.logger = logger;
+    this.clientSessions = new Map();
+    this.mcpServerBaseUrl = 'http://localhost:9851/mcp';
+    this.cleanupIntervalId = null;
+    this.startCleanupJob();
+  }
+
+  /**
+   * Get session key
+   */
+  getSessionKey(serverName, sessionId) {
+    return `${serverName}:${sessionId}`;
+  }
+
+  /**
+   * Get or create client for a session and server
+   */
+  async getOrCreateClient(serverName, sessionId) {
+    const sessionKey = this.getSessionKey(serverName, sessionId);
+    if (this.clientSessions.has(sessionKey)) {
+      return this.clientSessions.get(sessionKey);
+    }
+
+    if (!serverName) {
+      throw new ValidationError('Server name is required');
+    }
+
+    const mcpServerUrl = `${this.mcpServerBaseUrl}/${encodeURIComponent(serverName)}`;
+
+    const client = new Client(
+      { name: 'mcp-shark-playground', version: '1.0.0' },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {},
+        },
+      }
+    );
+
+    const transport = new StreamableHTTPClientTransport(new URL(mcpServerUrl));
+    await client.connect(transport);
+
+    const clientWrapper = {
+      client,
+      transport,
+      createdAt: Date.now(),
+      lastAccessed: Date.now(),
+      close: async () => {
+        await client.close();
+        transport.close?.();
+      },
+    };
+
+    this.clientSessions.set(sessionKey, clientWrapper);
+    return clientWrapper;
+  }
+
+  /**
+   * Update last accessed time for a session
+   */
+  updateLastAccessed(serverName, sessionId) {
+    const sessionKey = this.getSessionKey(serverName, sessionId);
+    const clientWrapper = this.clientSessions.get(sessionKey);
+    if (clientWrapper) {
+      clientWrapper.lastAccessed = Date.now();
+    }
+  }
+
+  /**
+   * Execute MCP method
+   */
+  async executeMethod(client, method, params) {
+    switch (method) {
+      case 'tools/list':
+        return await client.listTools();
+      case 'tools/call':
+        if (!params?.name) {
+          throw new ValidationError('Tool name is required');
+        }
+        return await client.callTool({
+          name: params.name,
+          arguments: params.arguments || {},
+        });
+      case 'prompts/list':
+        return await client.listPrompts();
+      case 'prompts/get':
+        if (!params?.name) {
+          throw new ValidationError('Prompt name is required');
+        }
+        return await client.getPrompt({
+          name: params.name,
+          arguments: params.arguments || {},
+        });
+      case 'resources/list':
+        return await client.listResources();
+      case 'resources/read':
+        if (!params?.uri) {
+          throw new ValidationError('Resource URI is required');
+        }
+        return await client.readResource({ uri: params.uri });
+      default:
+        throw new ValidationError(`Unsupported method: ${method}`);
+    }
+  }
+
+  /**
+   * Close client connection
+   */
+  async closeClient(serverName, sessionId) {
+    const sessionKey = this.getSessionKey(serverName, sessionId);
+    if (this.clientSessions.has(sessionKey)) {
+      const clientWrapper = this.clientSessions.get(sessionKey);
+      await clientWrapper.close();
+      this.clientSessions.delete(sessionKey);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Cleanup session (close all clients for a session)
+   */
+  async cleanupSession(sessionId) {
+    const keysToDelete = [];
+    for (const [key, clientWrapper] of this.clientSessions.entries()) {
+      if (key.endsWith(`:${sessionId}`)) {
+        await clientWrapper.close();
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.clientSessions.delete(key);
+    }
+    return keysToDelete.length;
+  }
+
+  /**
+   * Cleanup stale client sessions based on timeout
+   */
+  async cleanupStaleSessions() {
+    const now = Date.now();
+    const staleThreshold = now - ServerConstants.MCP_CLIENT_SESSION_TIMEOUT_MS;
+    const keysToDelete = [];
+
+    for (const [key, clientWrapper] of this.clientSessions.entries()) {
+      if (clientWrapper.lastAccessed < staleThreshold) {
+        try {
+          await clientWrapper.close();
+          keysToDelete.push(key);
+        } catch (error) {
+          this.logger?.error(
+            { error: error.message, sessionKey: key },
+            'Error closing stale MCP client session'
+          );
+        }
+      }
+    }
+
+    for (const key of keysToDelete) {
+      this.clientSessions.delete(key);
+    }
+
+    if (keysToDelete.length > 0) {
+      this.logger?.info({ count: keysToDelete.length }, 'Cleaned up stale MCP client sessions');
+    }
+
+    return keysToDelete.length;
+  }
+
+  /**
+   * Start periodic cleanup job for stale sessions
+   */
+  startCleanupJob() {
+    if (this.cleanupIntervalId) {
+      return;
+    }
+
+    // Run cleanup every 5 minutes
+    this.cleanupIntervalId = setInterval(
+      () => {
+        this.cleanupStaleSessions().catch((error) => {
+          this.logger?.error({ error: error.message }, 'Error in MCP client session cleanup job');
+        });
+      },
+      5 * 60 * 1000
+    );
+  }
+
+  /**
+   * Stop cleanup job
+   */
+  stopCleanupJob() {
+    if (this.cleanupIntervalId) {
+      clearInterval(this.cleanupIntervalId);
+      this.cleanupIntervalId = null;
+    }
+  }
+
+  /**
+   * Cleanup all client sessions (for shutdown)
+   */
+  async cleanupAll() {
+    this.stopCleanupJob();
+    const keysToDelete = Array.from(this.clientSessions.keys());
+
+    for (const key of keysToDelete) {
+      try {
+        const clientWrapper = this.clientSessions.get(key);
+        if (clientWrapper) {
+          await clientWrapper.close();
+        }
+      } catch (error) {
+        this.logger?.error(
+          { error: error.message, sessionKey: key },
+          'Error closing MCP client session during cleanup'
+        );
+      }
+      this.clientSessions.delete(key);
+    }
+
+    return keysToDelete.length;
+  }
+}