@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/ui/server/controllers/ServerManagementController.js

@@ -0,0 +1,154 @@
+import { StatusCodes } from '#core/constants/index.js';
+import { handleError, handleValidationError } from '../utils/errorHandler.js';
+
+/**
+ * Controller for server management HTTP endpoints
+ */
+export class ServerManagementController {
+  constructor(serverManagementService, logService, logger) {
+    this.serverManagementService = serverManagementService;
+    this.logService = logService;
+    this.logger = logger;
+  }
+
+  /**
+   * Add log entry
+   */
+  _addLogEntry(type, message) {
+    const timestamp = new Date().toISOString();
+    const log = { timestamp, type, line: message };
+    this.logService.addLog(log);
+  }
+
+  setup = async (req, res) => {
+    try {
+      this.logger?.debug({ body: req.body }, 'Setup request received');
+      const { filePath, fileContent, selectedServices } = req.body;
+
+      if (!filePath && !fileContent) {
+        return handleValidationError(
+          'Either filePath or fileContent is required',
+          res,
+          this.logger
+        );
+      }
+
+      const setupResult = await this.serverManagementService.setup({
+        filePath,
+        fileContent,
+        selectedServices,
+        port: 9851,
+        onError: (err) => {
+          this._addLogEntry('error', `Failed to start mcp-shark server: ${err.message}`);
+          throw err;
+        },
+        onReady: () => {
+          this._addLogEntry('info', 'MCP Shark server is ready!');
+        },
+      });
+
+      if (!setupResult.success) {
+        const statusCode =
+          setupResult.error === 'File not found' ? StatusCodes.NOT_FOUND : StatusCodes.BAD_REQUEST;
+        return res.status(statusCode).json(setupResult);
+      }
+
+      // Add log entries for setup process
+      this._addLogEntry('info', '[UI Server] Starting MCP-Shark server as library...');
+
+      if (setupResult.warning) {
+        this._addLogEntry('warn', `[WARNING] ${setupResult.warning}`);
+      }
+
+      res.json(setupResult);
+    } catch (error) {
+      const timestamp = new Date().toISOString();
+      const errorLog = {
+        timestamp,
+        type: 'error',
+        line: `[ERROR] Failed to setup mcp-shark server: ${error.message}`,
+      };
+      this.logService.addLog(errorLog);
+      handleError(error, res, this.logger, 'Error setting up mcp-shark server');
+    }
+  };
+
+  stop = async (_req, res) => {
+    try {
+      const stopped = await this.serverManagementService.stopServer();
+      const restored = this.configService.restoreOriginalConfig();
+
+      if (stopped) {
+        if (restored) {
+          const timestamp = new Date().toISOString();
+          const restoreLog = {
+            timestamp,
+            type: 'stdout',
+            line: '[RESTORE] Restored original config',
+          };
+          this.logService.addLog(restoreLog);
+        }
+        res.json({
+          success: true,
+          message: 'MCP Shark server stopped and config restored',
+        });
+      } else {
+        res.json({ success: true, message: 'MCP Shark server was not running' });
+      }
+    } catch (error) {
+      handleError(error, res, this.logger, 'Error stopping server');
+    }
+  };
+
+  getStatus = (_req, res) => {
+    try {
+      const status = this.serverManagementService.getServerStatus();
+      res.json(status);
+    } catch (error) {
+      handleError(error, res, this.logger, 'Error getting server status');
+    }
+  };
+
+  /**
+   * GET /api/mcp-server/status
+   * Check if the MCP server (gateway) is running
+   * This endpoint specifically indicates whether the MCP gateway server is active
+   * so users can know if they should focus on the traffic page
+   */
+  getMcpServerStatus = (_req, res) => {
+    try {
+      const status = this.serverManagementService.getServerStatus();
+      res.json({
+        running: status.running,
+        message: status.running
+          ? 'MCP server (gateway) is running and ready to receive traffic'
+          : 'MCP server (gateway) is not running. Start the server to begin capturing traffic.',
+      });
+    } catch (error) {
+      handleError(error, res, this.logger, 'Error getting MCP server status');
+    }
+  };
+
+  shutdown = async (_req, res) => {
+    try {
+      if (!this.cleanup) {
+        return res.status(StatusCodes.SERVICE_UNAVAILABLE).json({
+          error: 'ServiceUnavailableError',
+          message: 'Shutdown not available',
+          details: 'Cleanup function not configured',
+        });
+      }
+
+      const result = await this.serverManagementService.shutdown(this.cleanup);
+
+      res.json(result);
+
+      // Give time for response to be sent before process exits
+      setTimeout(() => {
+        process.exit(0);
+      }, 100);
+    } catch (error) {
+      handleError(error, res, this.logger, 'Error shutting down application');
+    }
+  };
+}

package/ui/server/controllers/SessionController.js

@@ -0,0 +1,57 @@
+import { Defaults } from '#core/constants/Defaults.js';
+import { StatusCodes } from '#core/constants/StatusCodes.js';
+import { SessionFilters } from '#core/models/SessionFilters.js';
+
+/**
+ * Controller for session-related HTTP endpoints
+ */
+
+export class SessionController {
+  constructor(sessionService, serializationLib, logger) {
+    this.sessionService = sessionService;
+    this.serializationLib = serializationLib;
+    this.logger = logger;
+  }
+
+  /**
+   * GET /api/sessions
+   */
+  getSessions(req, res) {
+    try {
+      const filters = new SessionFilters({
+        startTime: req.query.startTime || null,
+        endTime: req.query.endTime || null,
+        limit: req.query.limit,
+        offset: req.query.offset,
+      });
+      const sessions = this.sessionService.getSessions(filters);
+      const serialized = this.serializationLib.serializeBigInt(sessions);
+      res.json(serialized);
+    } catch (error) {
+      this.logger.error({ error: error.message }, 'Error in getSessions');
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to query sessions',
+        details: error.message,
+      });
+    }
+  }
+
+  /**
+   * GET /api/sessions/:sessionId/requests
+   */
+  getSessionRequests(req, res) {
+    try {
+      const sessionId = req.params.sessionId;
+      const limit = req.query.limit || Defaults.DEFAULT_SESSION_LIMIT;
+      const requests = this.sessionService.getSessionRequests(sessionId, limit);
+      const serialized = this.serializationLib.serializeBigInt(requests);
+      res.json(serialized);
+    } catch (error) {
+      this.logger.error({ error: error.message }, 'Error in getSessionRequests');
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to get session requests',
+        details: error.message,
+      });
+    }
+  }
+}

package/ui/server/controllers/SettingsController.js

@@ -0,0 +1,24 @@
+import { StatusCodes } from '#core/constants/index.js';
+
+/**
+ * Controller for settings HTTP endpoints
+ */
+export class SettingsController {
+  constructor(settingsService, logger) {
+    this.settingsService = settingsService;
+    this.logger = logger;
+  }
+
+  getSettings = (_req, res) => {
+    try {
+      const settings = this.settingsService.getSettings();
+      res.json(settings);
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error getting settings');
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to get settings',
+        details: error.message,
+      });
+    }
+  };
+}

package/ui/server/controllers/StatisticsController.js

@@ -0,0 +1,54 @@
+import { StatusCodes } from '#core/constants/StatusCodes.js';
+import { RequestFilters } from '#core/models/RequestFilters.js';
+
+/**
+ * Controller for statistics-related HTTP endpoints
+ */
+
+export class StatisticsController {
+  constructor(statisticsService, serializationLib, logger) {
+    this.statisticsService = statisticsService;
+    this.serializationLib = serializationLib;
+    this.logger = logger;
+  }
+
+  /**
+   * Sanitize search parameter
+   */
+  _sanitizeSearch(value) {
+    if (value !== undefined && value !== null) {
+      const trimmed = String(value).trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+    return null;
+  }
+
+  /**
+   * GET /api/statistics
+   */
+  getStatistics(req, res) {
+    try {
+      const filters = new RequestFilters({
+        sessionId: req.query.sessionId ? String(req.query.sessionId).trim() : null,
+        direction: req.query.direction ? String(req.query.direction).trim() : null,
+        method: req.query.method ? String(req.query.method).trim() : null,
+        jsonrpcMethod: req.query.jsonrpcMethod ? String(req.query.jsonrpcMethod).trim() : null,
+        statusCode: req.query.statusCode ? Number.parseInt(req.query.statusCode) : null,
+        jsonrpcId: req.query.jsonrpcId ? String(req.query.jsonrpcId).trim() : null,
+        search: this._sanitizeSearch(req.query.search),
+        serverName: req.query.serverName ? String(req.query.serverName).trim() : null,
+        startTime: req.query.startTime || null,
+        endTime: req.query.endTime || null,
+      });
+      const stats = this.statisticsService.getStatistics(filters);
+      const serialized = this.serializationLib.serializeBigInt(stats);
+      res.json(serialized);
+    } catch (error) {
+      this.logger.error({ error: error.message }, 'Error in getStatistics');
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to get statistics',
+        details: error.message,
+      });
+    }
+  }
+}

package/ui/server/controllers/TokenController.js

@@ -0,0 +1,58 @@
+import { StatusCodes } from '#core/constants/index.js';
+
+/**
+ * Controller for Smart Scan token HTTP endpoints
+ */
+export class TokenController {
+  constructor(tokenService, logger) {
+    this.tokenService = tokenService;
+    this.logger = logger;
+  }
+
+  getToken = (_req, res) => {
+    try {
+      const token = this.tokenService.readToken();
+      return res.json({
+        success: true,
+        token: token || null,
+      });
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error reading Smart Scan token');
+      return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to read token',
+        message: error.message,
+      });
+    }
+  };
+
+  saveToken = (req, res) => {
+    try {
+      const { token } = req.body;
+
+      if (token === undefined) {
+        return res.status(StatusCodes.BAD_REQUEST).json({
+          error: 'Token is required',
+        });
+      }
+
+      const success = this.tokenService.writeToken(token);
+
+      if (!success) {
+        return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+          error: 'Failed to save token',
+        });
+      }
+
+      return res.json({
+        success: true,
+        message: 'Token saved successfully',
+      });
+    } catch (error) {
+      this.logger?.error({ error: error.message }, 'Error saving Smart Scan token');
+      return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to save token',
+        message: error.message,
+      });
+    }
+  };
+}

package/ui/server/controllers/index.js

@@ -0,0 +1,17 @@
+/**
+ * Controller layer exports
+ * Controllers handle HTTP concerns: extraction, sanitization, serialization, formatting
+ */
+export { RequestController } from './RequestController.js';
+export { SessionController } from './SessionController.js';
+export { ConversationController } from './ConversationController.js';
+export { StatisticsController } from './StatisticsController.js';
+export { ConfigController } from './ConfigController.js';
+export { BackupController } from './BackupController.js';
+export { LogController } from './LogController.js';
+export { ScanController } from './ScanController.js';
+export { McpDiscoveryController } from './McpDiscoveryController.js';
+export { McpClientController } from './McpClientController.js';
+export { TokenController } from './TokenController.js';
+export { SettingsController } from './SettingsController.js';
+export { ServerManagementController } from './ServerManagementController.js';

package/ui/server/routes/backups/index.js

@@ -1,15 +1,21 @@
-import { deleteBackup } from './deleteBackup.js';
-import { listBackups } from './listBackups.js';
-import { restoreBackup } from './restoreBackup.js';
-import { viewBackup } from './viewBackup.js';
+import { BackupController } from '#ui/server/controllers/index.js';
+
+/**
+ * Create backup routes
+ * Routes delegate to BackupController which calls BackupService
+ */
+export function createBackupRoutes(container) {
+  const backupService = container.getService('backup');
+  const serverManagementService = container.getService('serverManagement');
+  const logger = container.getLibrary('logger');
+  const backupController = new BackupController(backupService, serverManagementService, logger);
 
-export function createBackupRoutes() {
   const router = {};
 
-  router.listBackups = listBackups;
-  router.restoreBackup = restoreBackup;
-  router.viewBackup = viewBackup;
-  router.deleteBackup = deleteBackup;
+  router.listBackups = backupController.listBackups;
+  router.restoreBackup = backupController.restoreBackup;
+  router.viewBackup = backupController.viewBackup;
+  router.deleteBackup = backupController.deleteBackup;
 
   return router;
 }

package/ui/server/routes/composite/index.js

@@ -1,46 +1,77 @@
+import { ServerManagementController } from '#ui/server/controllers/index.js';
 import { getServers } from './servers.js';
-import { setup } from './setup.js';
-import { getStatus } from './status.js';
-import { stop } from './stop.js';
 
+function getServerInstanceWrapper(getMcpSharkProcess, originalGetInstance) {
+  return getMcpSharkProcess() || originalGetInstance();
+}
+
+function createGetServerInstance(getMcpSharkProcess, originalGetInstance) {
+  return () => {
+    return getServerInstanceWrapper(getMcpSharkProcess, originalGetInstance);
+  };
+}
+
+function setServerInstanceWrapper(setMcpSharkProcess, serverManagementService, instance) {
+  setMcpSharkProcess(instance);
+  serverManagementService.serverInstance = instance;
+}
+
+function createSetServerInstance(setMcpSharkProcess, serverManagementService) {
+  return (instance) => {
+    setServerInstanceWrapper(setMcpSharkProcess, serverManagementService, instance);
+  };
+}
+
+/**
+ * Create composite routes
+ * Routes delegate to controllers which call services
+ */
 export function createCompositeRoutes(
+  container,
   getMcpSharkProcess,
   setMcpSharkProcess,
   mcpSharkLogs,
-  broadcastLogUpdate
+  _broadcastLogUpdate,
+  cleanup
 ) {
-  const router = {};
+  const serverManagementService = container.getService('serverManagement');
+  const logService = container.getService('log');
+  const logger = container.getLibrary('logger');
 
-  router.setup = async (req, res) => {
-    return setup(
-      req,
-      res,
-      getMcpSharkProcess,
-      setMcpSharkProcess,
-      mcpSharkLogs,
-      broadcastLogUpdate
-    );
-  };
+  // Initialize log service with the log array
+  logService.initialize(mcpSharkLogs);
 
-  router.stop = async (req, res, restoreOriginalConfig) => {
-    return stop(
-      req,
-      res,
-      restoreOriginalConfig,
-      getMcpSharkProcess,
-      setMcpSharkProcess,
-      mcpSharkLogs,
-      broadcastLogUpdate
-    );
-  };
+  // Set server instance getter/setter
+  const originalGetInstance =
+    serverManagementService.getServerInstance.bind(serverManagementService);
+  serverManagementService.getServerInstance = createGetServerInstance(
+    getMcpSharkProcess,
+    originalGetInstance
+  );
+  serverManagementService.setServerInstance = createSetServerInstance(
+    setMcpSharkProcess,
+    serverManagementService
+  );
 
-  router.getStatus = (req, res) => {
-    return getStatus(req, res, getMcpSharkProcess);
-  };
+  const serverManagementController = new ServerManagementController(
+    serverManagementService,
+    logService,
+    logger
+  );
 
-  router.getServers = (req, res) => {
-    return getServers(req, res);
-  };
+  // Set cleanup function for shutdown endpoint
+  if (cleanup) {
+    serverManagementController.cleanup = cleanup;
+  }
+
+  const router = {};
+
+  router.setup = serverManagementController.setup;
+  router.stop = serverManagementController.stop;
+  router.getStatus = serverManagementController.getStatus;
+  router.getMcpServerStatus = serverManagementController.getMcpServerStatus;
+  router.shutdown = serverManagementController.shutdown;
+  router.getServers = getServers(container);
 
   return router;
 }

package/ui/server/routes/composite/servers.js

@@ -1,18 +1,23 @@
-import * as fs from 'node:fs';
-import { getMcpConfigPath } from '#common/configs';
+import { StatusCodes } from '#core/constants/index.js';
 
-export function getServers(_req, res) {
-  try {
-    const mcpsJsonPath = getMcpConfigPath();
-    if (!fs.existsSync(mcpsJsonPath)) {
-      return res.json({ servers: [] });
-    }
+/**
+ * Get servers from config
+ * Uses ConfigService via ConfigController
+ */
+export function getServers(container) {
+  const configService = container.getService('config');
+  const logger = container.getLibrary('logger');
 
-    const configContent = fs.readFileSync(mcpsJsonPath, 'utf-8');
-    const config = JSON.parse(configContent);
-    const servers = config.servers ? Object.keys(config.servers) : [];
-    res.json({ servers });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to get servers', details: error.message });
-  }
+  return (_req, res) => {
+    try {
+      const servers = configService.getServersFromConfig();
+      res.json({ servers });
+    } catch (error) {
+      logger.error({ error: error.message }, 'Error getting servers');
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+        error: 'Failed to get servers',
+        details: error.message,
+      });
+    }
+  };
 }