@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/core/services/ServerManagementService.js

@@ -0,0 +1,206 @@
+import { initAuditLogger, startMcpSharkServer } from '#core/mcp-server/index.js';
+
+/**
+ * Service for managing MCP Shark server lifecycle
+ * Handles server startup, shutdown, and status
+ */
+export class ServerManagementService {
+  constructor(configService, configPatchingService, logger) {
+    this.configService = configService;
+    this.configPatchingService = configPatchingService;
+    this.logger = logger;
+    this.serverInstance = null;
+  }
+
+  /**
+   * Setup and start MCP Shark server
+   * Orchestrates the entire setup process: config processing, patching, and server startup
+   * @param {Object} options - Setup options
+   * @param {string} [options.filePath] - Path to config file
+   * @param {string} [options.fileContent] - Config file content
+   * @param {Array} [options.selectedServices] - Selected services to include
+   * @param {number} [options.port=9851] - Server port
+   * @param {Function} [options.onError] - Error callback
+   * @param {Function} [options.onReady] - Ready callback
+   * @returns {Promise<Object>} Setup result with convertedConfig, updatedConfig, filePath
+   */
+  async setup(options = {}) {
+    const { filePath, fileContent, selectedServices, port = 9851, onError, onReady } = options;
+
+    if (!filePath && !fileContent) {
+      return {
+        success: false,
+        error: 'Either filePath or fileContent is required',
+      };
+    }
+
+    // If filePath is provided, restore original config if already patched
+    // This ensures processSetup reads the original config, not the patched one
+    let restoreWarning = null;
+    if (filePath && !fileContent) {
+      const restoreResult = this.configPatchingService.restoreIfPatched(filePath);
+      if (restoreResult.warning) {
+        restoreWarning = restoreResult.warning;
+      }
+    }
+
+    // Process setup
+    const setupResult = this.configService.processSetup(filePath, fileContent, selectedServices);
+
+    if (!setupResult.success) {
+      return setupResult;
+    }
+
+    const { fileData, convertedConfig, updatedConfig } = setupResult;
+    const mcpsJsonPath = this.configService.getMcpConfigPath();
+
+    // Write converted config to MCP Shark config path
+    this.configService.writeConfigAsJson(mcpsJsonPath, convertedConfig);
+
+    // Stop existing server if running
+    if (this.serverInstance?.stop) {
+      await this.stopServer();
+    }
+
+    // Start server
+    await this.startServer({
+      configPath: mcpsJsonPath,
+      port,
+      onError: (err) => {
+        if (onError) {
+          onError(err);
+        }
+        throw err;
+      },
+      onReady: () => {
+        if (onReady) {
+          onReady();
+        }
+      },
+    });
+
+    // Patch the original config file if it exists
+    let patchWarning = null;
+    if (fileData.resolvedFilePath && this.configService.fileExists(fileData.resolvedFilePath)) {
+      const patchResult = this.configPatchingService.patchConfigFile(
+        fileData.resolvedFilePath,
+        updatedConfig
+      );
+      if (patchResult.warning) {
+        patchWarning = patchResult.warning;
+      }
+    }
+
+    return {
+      success: true,
+      message: 'MCP Shark server started successfully and config file updated',
+      convertedConfig,
+      updatedConfig,
+      filePath: fileData.resolvedFilePath || null,
+      backupPath: null, // TODO: Implement backup creation in BackupService
+      warning: restoreWarning || patchWarning || undefined,
+    };
+  }
+
+  /**
+   * Start MCP Shark server
+   */
+  async startServer(options = {}) {
+    const { configPath, port = 9851, onError, onReady } = options;
+
+    const mcpsJsonPath = configPath || this.configService.getMcpConfigPath();
+
+    if (this.serverInstance?.stop) {
+      await this.stopServer();
+    }
+
+    this.logger?.info({ path: mcpsJsonPath }, 'Starting MCP-Shark server as library...');
+
+    const auditLogger = initAuditLogger(this.logger);
+
+    const serverInstance = await startMcpSharkServer({
+      configPath: mcpsJsonPath,
+      port,
+      auditLogger,
+      onError: (err) => {
+        this.logger?.error({ error: err.message }, 'Failed to start mcp-shark server');
+        this.serverInstance = null;
+        if (onError) {
+          onError(err);
+        }
+        throw err;
+      },
+      onReady: () => {
+        this.logger?.info('MCP Shark server is ready!');
+        if (onReady) {
+          onReady();
+        }
+      },
+    });
+
+    this.serverInstance = serverInstance;
+    this.logger?.info('MCP Shark server started successfully');
+
+    return serverInstance;
+  }
+
+  /**
+   * Stop MCP Shark server
+   */
+  async stopServer() {
+    if (this.serverInstance?.stop) {
+      await this.serverInstance.stop();
+      this.serverInstance = null;
+      this.logger?.info('MCP Shark server stopped');
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get server status
+   */
+  getServerStatus() {
+    return {
+      running: this.serverInstance !== null,
+      pid: null, // No process PID when using library
+    };
+  }
+
+  /**
+   * Get current server instance
+   */
+  getServerInstance() {
+    return this.serverInstance;
+  }
+
+  /**
+   * Set server instance (for external management)
+   */
+  setServerInstance(instance) {
+    this.serverInstance = instance;
+  }
+
+  /**
+   * Shutdown the entire application
+   * @param {Function} cleanup - Cleanup function to execute
+   */
+  async shutdown(cleanup) {
+    if (!cleanup || typeof cleanup !== 'function') {
+      throw new Error('Cleanup function is required');
+    }
+
+    this.logger?.info('Initiating application shutdown...');
+
+    // Stop MCP Shark server if running
+    if (this.serverInstance?.stop) {
+      await this.stopServer();
+    }
+
+    // Execute cleanup
+    await cleanup();
+
+    this.logger?.info('Application shutdown complete');
+    return { success: true, message: 'Application shutdown initiated' };
+  }
+}

package/core/services/SessionService.js

@@ -0,0 +1,34 @@
+/**
+ * Service for session-related business logic
+ * HTTP-agnostic: accepts models, returns models
+ */
+import { Defaults } from '../constants/Defaults.js';
+
+export class SessionService {
+  constructor(sessionRepository, packetRepository) {
+    this.sessionRepository = sessionRepository;
+    this.packetRepository = packetRepository;
+  }
+
+  /**
+   * Get sessions with filters
+   * @param {SessionFilters} filters - Typed filter model
+   * @returns {Array} Array of session objects (raw from repository)
+   */
+  getSessions(filters) {
+    const repoFilters = filters.toRepositoryFilters();
+    return this.sessionRepository.getSessions(repoFilters);
+  }
+
+  /**
+   * Get requests for a specific session
+   * @param {string} sessionId - Session ID
+   * @param {number} limit - Maximum number of requests to return
+   * @returns {Array} Array of packet objects (raw from repository)
+   */
+  getSessionRequests(sessionId, limit) {
+    const parsedLimit =
+      limit !== undefined ? Number.parseInt(limit) : Defaults.DEFAULT_SESSION_LIMIT;
+    return this.packetRepository.getSessionRequests(sessionId, parsedLimit);
+  }
+}

package/core/services/SettingsService.js

@@ -0,0 +1,163 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getDatabaseFile, getWorkingDirectory } from '#core/configs/index.js';
+import { getScanResultsDirectory } from '#core/utils/scan-cache/directory.js';
+
+/**
+ * Service for application settings
+ * Handles retrieving application configuration and paths
+ */
+export class SettingsService {
+  constructor(tokenService, backupService, logger) {
+    this.tokenService = tokenService;
+    this.backupService = backupService;
+    this.logger = logger;
+  }
+
+  /**
+   * Convert absolute path to display path (replace home with ~)
+   */
+  _toDisplayPath(homeDir, absolutePath) {
+    return absolutePath.replace(homeDir, '~');
+  }
+
+  /**
+   * Get backup count from backup directories
+   */
+  _getBackupCount(cursorBackupDir, windsurfBackupDir, cursorConfigPath, windsurfConfigPath) {
+    try {
+      const backupDirs = [cursorBackupDir, windsurfBackupDir];
+      const newFormatCount = backupDirs.reduce((count, dir) => {
+        if (existsSync(dir)) {
+          const files = readdirSync(dir);
+          const matchingFiles = files.filter((file) => {
+            return /^\.(.+)-mcpshark\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.json$/.test(file);
+          });
+          return count + matchingFiles.length;
+        }
+        return count;
+      }, 0);
+
+      const commonPaths = [cursorConfigPath, windsurfConfigPath];
+      const oldFormatCount = commonPaths.reduce((count, configPath) => {
+        if (existsSync(`${configPath}.backup`)) {
+          return count + 1;
+        }
+        return count;
+      }, 0);
+
+      return newFormatCount + oldFormatCount;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error counting backups');
+      return 0;
+    }
+  }
+
+  /**
+   * Get all settings
+   */
+  getSettings() {
+    const homeDir = homedir();
+    const workingDir = getWorkingDirectory();
+    const databasePath = getDatabaseFile();
+    const scanResultsDir = getScanResultsDirectory();
+    const tokenMetadata = this.tokenService.getTokenMetadata();
+
+    const cursorConfigPath = join(homeDir, '.cursor', 'mcp.json');
+    const windsurfConfigPath = join(homeDir, '.codeium', 'windsurf', 'mcp_config.json');
+
+    const cursorBackupDir = join(homeDir, '.cursor');
+    const windsurfBackupDir = join(homeDir, '.codeium', 'windsurf');
+
+    return {
+      paths: {
+        workingDirectory: {
+          absolute: workingDir,
+          display: this._toDisplayPath(homeDir, workingDir),
+          exists: existsSync(workingDir),
+        },
+        database: {
+          absolute: databasePath,
+          display: this._toDisplayPath(homeDir, databasePath),
+          exists: existsSync(databasePath),
+        },
+        smartScanResults: {
+          absolute: scanResultsDir,
+          display: this._toDisplayPath(homeDir, scanResultsDir),
+          exists: existsSync(scanResultsDir),
+        },
+        smartScanToken: {
+          absolute: tokenMetadata.path,
+          display: this._toDisplayPath(homeDir, tokenMetadata.path),
+          exists: tokenMetadata.exists,
+        },
+        backupDirectories: {
+          cursor: {
+            absolute: cursorBackupDir,
+            display: this._toDisplayPath(homeDir, cursorBackupDir),
+            exists: existsSync(cursorBackupDir),
+          },
+          windsurf: {
+            absolute: windsurfBackupDir,
+            display: this._toDisplayPath(homeDir, windsurfBackupDir),
+            exists: existsSync(windsurfBackupDir),
+          },
+        },
+        configFiles: {
+          cursor: {
+            absolute: cursorConfigPath,
+            display: this._toDisplayPath(homeDir, cursorConfigPath),
+            exists: existsSync(cursorConfigPath),
+          },
+          windsurf: {
+            absolute: windsurfConfigPath,
+            display: this._toDisplayPath(homeDir, windsurfConfigPath),
+            exists: existsSync(windsurfConfigPath),
+          },
+        },
+      },
+      smartScan: {
+        token: tokenMetadata.token,
+        tokenPath: {
+          absolute: tokenMetadata.path,
+          display: this._toDisplayPath(homeDir, tokenMetadata.path),
+        },
+        tokenUpdatedAt: tokenMetadata.updatedAt,
+        tokenExists: tokenMetadata.exists,
+      },
+      database: {
+        path: {
+          absolute: databasePath,
+          display: this._toDisplayPath(homeDir, databasePath),
+        },
+        exists: existsSync(databasePath),
+      },
+      system: {
+        platform: process.platform,
+        homeDirectory: {
+          absolute: homeDir,
+          display: '~',
+        },
+      },
+      backups: {
+        directories: [
+          {
+            absolute: cursorBackupDir,
+            display: this._toDisplayPath(homeDir, cursorBackupDir),
+          },
+          {
+            absolute: windsurfBackupDir,
+            display: this._toDisplayPath(homeDir, windsurfBackupDir),
+          },
+        ],
+        count: this._getBackupCount(
+          cursorBackupDir,
+          windsurfBackupDir,
+          cursorConfigPath,
+          windsurfConfigPath
+        ),
+      },
+    };
+  }
+}

package/core/services/StatisticsService.js

@@ -0,0 +1,64 @@
+import { Defaults } from '../constants/Defaults.js';
+import { StatusCodeRanges } from '../constants/StatusCodes.js';
+/**
+ * Service for statistics-related business logic
+ * HTTP-agnostic: accepts models, returns models
+ */
+import { RequestFilters } from '../models/RequestFilters.js';
+
+export class StatisticsService {
+  constructor(statisticsRepository, packetRepository, conversationRepository) {
+    this.statisticsRepository = statisticsRepository;
+    this.packetRepository = packetRepository;
+    this.conversationRepository = conversationRepository;
+  }
+
+  /**
+   * Get statistics with filters
+   * @param {RequestFilters} filters - Typed filter model
+   * @returns {Object} Statistics object
+   */
+  getStatistics(filters) {
+    // Get all filtered requests for accurate statistics
+    const statsFilters = new RequestFilters({
+      ...filters,
+      limit: Defaults.STATISTICS_LIMIT,
+      offset: Defaults.DEFAULT_OFFSET,
+    });
+    const repoFilters = statsFilters.toRepositoryFilters();
+    const allRequests = this.packetRepository.queryRequests(repoFilters);
+
+    // Calculate statistics from filtered requests
+    const totalPackets = allRequests.length;
+    const totalRequests = allRequests.filter((r) => r.direction === 'request').length;
+    const totalResponses = allRequests.filter((r) => r.direction === 'response').length;
+    const totalErrors = allRequests.filter((r) => {
+      if (r.direction === 'response') {
+        const statusCode = r.status_code || r.status;
+        return (
+          statusCode >= StatusCodeRanges.CLIENT_ERROR_MIN ||
+          (r.body_json && typeof r.body_json === 'object' && r.body_json.error)
+        );
+      }
+      return false;
+    }).length;
+
+    // Get unique sessions
+    const uniqueSessions = new Set();
+    for (const r of allRequests) {
+      if (r.session_id) {
+        uniqueSessions.add(r.session_id);
+      }
+    }
+
+    const stats = {
+      total_packets: totalPackets,
+      total_requests: totalRequests,
+      total_responses: totalResponses,
+      total_errors: totalErrors,
+      unique_sessions: uniqueSessions.size,
+    };
+
+    return stats;
+  }
+}

package/core/services/TokenService.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getWorkingDirectory, prepareAppDataSpaces } from '#core/configs/index.js';
+
+/**
+ * Service for Smart Scan token management
+ * Handles reading and writing Smart Scan API tokens
+ */
+export class TokenService {
+  constructor(logger) {
+    this.logger = logger;
+    this.tokenFileName = 'smart-scan-token.json';
+  }
+
+  /**
+   * Get token file path
+   */
+  getTokenPath() {
+    return join(getWorkingDirectory(), this.tokenFileName);
+  }
+
+  /**
+   * Read Smart Scan token
+   */
+  readToken() {
+    try {
+      const tokenPath = this.getTokenPath();
+      if (existsSync(tokenPath)) {
+        const content = readFileSync(tokenPath, 'utf8');
+        const data = JSON.parse(content);
+        return data.token || null;
+      }
+      return null;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error reading Smart Scan token');
+      return null;
+    }
+  }
+
+  /**
+   * Write Smart Scan token
+   */
+  writeToken(token) {
+    try {
+      const tokenPath = this.getTokenPath();
+      prepareAppDataSpaces();
+
+      const data = {
+        token: token || null,
+        updatedAt: new Date().toISOString(),
+      };
+
+      writeFileSync(tokenPath, JSON.stringify(data, null, 2), { mode: 0o600 });
+      return true;
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error writing Smart Scan token');
+      return false;
+    }
+  }
+
+  /**
+   * Get token metadata
+   */
+  getTokenMetadata() {
+    try {
+      const tokenPath = this.getTokenPath();
+      if (existsSync(tokenPath)) {
+        const content = readFileSync(tokenPath, 'utf8');
+        const data = JSON.parse(content);
+        const stats = statSync(tokenPath);
+        return {
+          token: data.token || null,
+          updatedAt: data.updatedAt || stats.mtime.toISOString(),
+          path: tokenPath,
+          exists: true,
+        };
+      }
+      return {
+        token: null,
+        updatedAt: null,
+        path: tokenPath,
+        exists: false,
+      };
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error reading token metadata');
+      return {
+        token: null,
+        updatedAt: null,
+        path: this.getTokenPath(),
+        exists: false,
+      };
+    }
+  }
+}

package/core/services/index.js

@@ -0,0 +1,25 @@
+/**
+ * Service layer exports
+ * All business logic should go through services
+ */
+export { RequestService } from './RequestService.js';
+export { SessionService } from './SessionService.js';
+export { ConversationService } from './ConversationService.js';
+export { StatisticsService } from './StatisticsService.js';
+export { AuditService } from './AuditService.js';
+export { ConfigService } from './ConfigService.js';
+export { ConfigFileService } from './ConfigFileService.js';
+export { ConfigTransformService } from './ConfigTransformService.js';
+export { ConfigDetectionService } from './ConfigDetectionService.js';
+export { ServerManagementService } from './ServerManagementService.js';
+export { BackupService } from './BackupService.js';
+export { LogService } from './LogService.js';
+export { ScanCacheService } from './ScanCacheService.js';
+export { ScanService } from './ScanService.js';
+export { McpDiscoveryService } from './McpDiscoveryService.js';
+export { McpClientService } from './McpClientService.js';
+export { TokenService } from './TokenService.js';
+export { SettingsService } from './SettingsService.js';
+export { ConfigPatchingService } from './ConfigPatchingService.js';
+export { ExportService } from './ExportService.js';
+export * from './parsers/index.js';

package/core/services/parsers/ConfigParserFactory.js

@@ -0,0 +1,113 @@
+import * as path from 'node:path';
+import { JsonConfigParser } from './JsonConfigParser.js';
+import { LegacyJsonConfigParser } from './LegacyJsonConfigParser.js';
+import { TomlConfigParser } from './TomlConfigParser.js';
+
+/**
+ * Factory for creating appropriate config parsers based on file type
+ * Provides unified interface for all config format parsing
+ */
+export class ConfigParserFactory {
+  constructor() {
+    this.tomlParser = new TomlConfigParser();
+    this.jsonParser = new JsonConfigParser();
+    this.legacyParser = new LegacyJsonConfigParser();
+  }
+
+  /**
+   * Detect file format from path
+   * @param {string} filePath - File path
+   * @returns {string} Format type: 'toml', 'json', or null
+   */
+  detectFormat(filePath) {
+    if (!filePath) {
+      return null;
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.toml' ? 'toml' : ext === '.json' ? 'json' : null;
+  }
+
+  /**
+   * Get appropriate parser for file format
+   * @param {string} filePath - File path
+   * @returns {TomlConfigParser|JsonConfigParser|LegacyJsonConfigParser} Parser instance
+   */
+  getParser(filePath) {
+    const format = this.detectFormat(filePath);
+    if (format === 'toml') {
+      return this.tomlParser;
+    }
+    return this.jsonParser;
+  }
+
+  /**
+   * Parse config content and detect format
+   * @param {string} content - Config file content
+   * @param {string} filePath - File path (optional, for format detection)
+   * @returns {Object|null} Parsed config or null on error
+   */
+  parse(content, filePath = null) {
+    const format = filePath ? this.detectFormat(filePath) : null;
+
+    if (format === 'toml') {
+      return this.tomlParser.parse(content);
+    }
+
+    return this.jsonParser.parse(content);
+  }
+
+  /**
+   * Normalize config to internal format
+   * Handles all formats: TOML (Codex), JSON (standard), JSON (legacy)
+   * @param {Object} config - Parsed config object
+   * @param {string} filePath - Original file path (optional)
+   * @returns {Object|null} Normalized config in internal format
+   */
+  normalizeToInternalFormat(config, _filePath = null) {
+    if (!config || typeof config !== 'object') {
+      return null;
+    }
+
+    // Try TOML format first (Codex)
+    if (this.tomlParser.isCodexFormat(config)) {
+      return this.tomlParser.convertToMcpSharkFormat(config);
+    }
+
+    // Try standard JSON format
+    if (this.jsonParser.isMcpServersFormat(config)) {
+      return this.jsonParser.normalizeToInternalFormat(config);
+    }
+
+    // Try legacy format
+    if (this.legacyParser.isLegacyFormat(config)) {
+      return this.legacyParser.convertToInternalFormat(config);
+    }
+
+    // If config has both mcpServers and servers, prefer mcpServers
+    if (config.mcpServers && typeof config.mcpServers === 'object') {
+      return this.jsonParser.normalizeToInternalFormat(config);
+    }
+
+    // If config has servers, treat as legacy
+    if (config.servers && typeof config.servers === 'object') {
+      return this.legacyParser.convertToInternalFormat(config);
+    }
+
+    return null;
+  }
+
+  /**
+   * Parse and normalize config in one step
+   * @param {string} content - Config file content
+   * @param {string} filePath - File path
+   * @returns {Object|null} Normalized config in internal format or null
+   */
+  parseAndNormalize(content, filePath) {
+    const parsed = this.parse(content, filePath);
+    if (!parsed) {
+      return null;
+    }
+
+    return this.normalizeToInternalFormat(parsed, filePath);
+  }
+}