@mcp-shark/mcp-shark 1.5.4 → 1.5.5

package/ui/server/setup.js

@@ -0,0 +1,162 @@
+import { createServer } from 'node:http';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import express from 'express';
+import swaggerUi from 'swagger-ui-express';
+import { WebSocketServer } from 'ws';
+
+import { DependencyContainer } from '#core';
+import { getDatabaseFile, prepareAppDataSpaces } from '#core/configs/index.js';
+import { Server as ServerConstants } from '#core/constants/Server.js';
+import { openDb } from '#core/db/init.js';
+
+import { createBackupRoutes } from './routes/backups/index.js';
+import { createCompositeRoutes } from './routes/composite/index.js';
+import { createConfigRoutes } from './routes/config.js';
+import { createConversationsRoutes } from './routes/conversations.js';
+import { createHelpRoutes } from './routes/help.js';
+import { createLogsRoutes } from './routes/logs.js';
+import { createPlaygroundRoutes } from './routes/playground.js';
+import { createRequestsRoutes } from './routes/requests.js';
+import { createSessionsRoutes } from './routes/sessions.js';
+import { createSettingsRoutes } from './routes/settings.js';
+import { createSmartScanRoutes } from './routes/smartscan.js';
+import { createStatisticsRoutes } from './routes/statistics.js';
+import { swaggerSpec } from './swagger/swagger.js';
+import { performCleanup } from './utils/cleanup.js';
+import { restoreConfig } from './utils/config.js';
+import { getMcpSharkProcess, setMcpSharkProcess } from './utils/processState.js';
+import { broadcastLogUpdate, notifyClients } from './websocket/broadcast.js';
+import { handleWebSocketConnection } from './websocket/handler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Create and configure UI server
+ * @returns {{server: object, cleanup: Function, logger: object}}
+ */
+export function createUIServer() {
+  prepareAppDataSpaces();
+
+  const db = openDb(getDatabaseFile());
+  const container = new DependencyContainer(db);
+  const app = express();
+  const server = createServer(app);
+  const wss = new WebSocketServer({ server });
+
+  app.use(express.json());
+
+  // Swagger/OpenAPI documentation
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
+
+  const clients = new Set();
+  const mcpSharkLogs = [];
+  const processState = { mcpSharkServer: null };
+  const logger = container.getLibrary('logger');
+
+  wss.on('connection', (ws) => handleWebSocketConnection(clients, ws, logger));
+
+  const requestsRoutes = createRequestsRoutes(container);
+  const conversationsRoutes = createConversationsRoutes(container);
+  const sessionsRoutes = createSessionsRoutes(container);
+  const statisticsRoutes = createStatisticsRoutes(container);
+  const logsRoutes = createLogsRoutes(container, mcpSharkLogs);
+  const configRoutes = createConfigRoutes(container);
+  const backupRoutes = createBackupRoutes(container);
+
+  const cleanup = async () => {
+    return performCleanup(intervalId, processState, clients, wss, server, container, logger);
+  };
+
+  const compositeRoutes = createCompositeRoutes(
+    container,
+    () => getMcpSharkProcess(processState),
+    (server) => setMcpSharkProcess(processState, server),
+    mcpSharkLogs,
+    (logEntry) => broadcastLogUpdate(clients, logEntry),
+    cleanup
+  );
+  const helpRoutes = createHelpRoutes();
+  const playgroundRoutes = createPlaygroundRoutes(container);
+  const smartScanRoutes = createSmartScanRoutes(container);
+  const settingsRoutes = createSettingsRoutes(container);
+
+  app.get('/api/requests', requestsRoutes.getRequests);
+  app.get('/api/packets', requestsRoutes.getRequests);
+  app.get('/api/requests/:frameNumber', requestsRoutes.getRequest);
+  app.get('/api/packets/:frameNumber', requestsRoutes.getRequest);
+  app.get('/api/requests/export', requestsRoutes.exportRequests);
+  app.post('/api/requests/clear', requestsRoutes.clearRequests);
+
+  app.get('/api/conversations', conversationsRoutes.getConversations);
+
+  app.get('/api/sessions', sessionsRoutes.getSessions);
+  app.get('/api/sessions/:sessionId/requests', sessionsRoutes.getSessionRequests);
+  app.get('/api/sessions/:sessionId/packets', sessionsRoutes.getSessionRequests);
+
+  app.get('/api/statistics', statisticsRoutes.getStatistics);
+
+  app.get('/api/composite/logs', logsRoutes.getLogs);
+  app.post('/api/composite/logs/clear', logsRoutes.clearLogs);
+  app.get('/api/composite/logs/export', logsRoutes.exportLogs);
+
+  app.post('/api/config/services', configRoutes.extractServices);
+  app.get('/api/config/read', configRoutes.readConfig);
+  app.get('/api/config/detect', configRoutes.detectConfig);
+  app.get('/api/config/backups', backupRoutes.listBackups);
+  app.get('/api/config/backup/view', backupRoutes.viewBackup);
+  app.post('/api/config/restore', backupRoutes.restoreBackup);
+  app.post('/api/config/backup/delete', backupRoutes.deleteBackup);
+
+  app.post('/api/composite/setup', compositeRoutes.setup);
+  app.post('/api/composite/stop', (req, res) => {
+    compositeRoutes.stop(req, res, () => restoreConfig(container));
+  });
+  app.get('/api/composite/status', compositeRoutes.getStatus);
+  app.post('/api/composite/shutdown', compositeRoutes.shutdown);
+  app.get('/api/composite/servers', compositeRoutes.getServers);
+
+  app.get('/api/help/state', helpRoutes.getState);
+  app.post('/api/help/dismiss', helpRoutes.dismiss);
+  app.post('/api/help/reset', helpRoutes.reset);
+
+  app.post('/api/playground/proxy', playgroundRoutes.proxyRequest);
+
+  app.post('/api/smartscan/scans', smartScanRoutes.createScan);
+  app.get('/api/smartscan/scans', smartScanRoutes.listScans);
+  app.get('/api/smartscan/scans/:scanId', smartScanRoutes.getScan);
+  app.get('/api/smartscan/token', smartScanRoutes.getToken);
+  app.post('/api/smartscan/token', smartScanRoutes.saveToken);
+  app.get('/api/smartscan/discover', smartScanRoutes.discoverServers);
+  app.post('/api/smartscan/scans/batch', smartScanRoutes.createBatchScans);
+  app.post('/api/smartscan/cached-results', smartScanRoutes.getCachedResults);
+  app.post('/api/smartscan/cache/clear', smartScanRoutes.clearCache);
+
+  app.get('/api/settings', settingsRoutes.getSettings);
+
+  const staticPath = path.join(__dirname, '..', 'dist');
+  app.use(express.static(staticPath));
+
+  app.get('*', (_req, res) => {
+    res.sendFile(path.join(staticPath, 'index.html'));
+  });
+
+  const requestService = container.getService('request');
+  const serializationLib = container.getLibrary('serialization');
+  const packetRepository = container.getRepository('packet');
+
+  const timestampState = { lastTs: 0 };
+
+  function checkTimestampAndNotify() {
+    const lastCheck = packetRepository.getMaxTimestamp();
+    if (lastCheck && lastCheck.max_ts > timestampState.lastTs) {
+      timestampState.lastTs = lastCheck.max_ts;
+      notifyClients(clients, requestService, serializationLib);
+    }
+  }
+
+  const intervalId = setInterval(checkTimestampAndNotify, ServerConstants.PACKET_CHECK_INTERVAL_MS);
+
+  return { server, cleanup, logger, wss };
+}

package/ui/server/swagger/paths/backups.js

@@ -0,0 +1,151 @@
+/**
+ * Backups endpoints - Configuration backup management
+ */
+
+export const backupsPaths = {
+  '/api/config/backups': {
+    get: {
+      tags: ['Backups'],
+      summary: 'List backups',
+      description: 'Get a list of all configuration backups',
+      responses: {
+        200: {
+          description: 'List of backups',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'array',
+                items: { $ref: '#/components/schemas/Backup' },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/config/backup/view': {
+    get: {
+      tags: ['Backups'],
+      summary: 'View backup',
+      description: 'View the contents of a backup file',
+      parameters: [
+        {
+          name: 'backupPath',
+          in: 'query',
+          required: true,
+          description: 'Path to backup file',
+          schema: { type: 'string' },
+        },
+      ],
+      responses: {
+        200: {
+          description: 'Backup file content',
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+        404: {
+          description: 'Backup not found',
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/config/restore': {
+    post: {
+      tags: ['Backups'],
+      summary: 'Restore backup',
+      description: 'Restore a configuration file from a backup',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              required: ['backupPath'],
+              properties: {
+                backupPath: { type: 'string', description: 'Path to backup file' },
+                originalPath: { type: 'string', description: 'Path to original file (optional)' },
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Backup restored successfully',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  success: { type: 'boolean' },
+                  message: { type: 'string' },
+                  originalPath: { type: 'string' },
+                  wasPatched: { type: 'boolean' },
+                  repatched: { type: 'boolean' },
+                },
+              },
+            },
+          },
+        },
+        400: {
+          description: 'Bad request',
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/config/backup/delete': {
+    post: {
+      tags: ['Backups'],
+      summary: 'Delete backup',
+      description: 'Delete a configuration backup',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              required: ['backupPath'],
+              properties: {
+                backupPath: { type: 'string', description: 'Path to backup file' },
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Backup deleted successfully',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  success: { type: 'boolean' },
+                  message: { type: 'string' },
+                },
+              },
+            },
+          },
+        },
+        404: {
+          description: 'Backup not found',
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+};

package/ui/server/swagger/paths/components.js

@@ -0,0 +1,76 @@
+/**
+ * OpenAPI component schemas
+ */
+
+export const components = {
+  schemas: {
+    Request: {
+      type: 'object',
+      properties: {
+        frame_number: { type: 'integer' },
+        timestamp_iso: { type: 'string' },
+        session_id: { type: 'string' },
+        server_name: { type: 'string' },
+        direction: { type: 'string' },
+        request: { type: 'object' },
+        response: { type: 'object' },
+        jsonrpc_method: { type: 'string' },
+        jsonrpc_id: { type: 'string' },
+        length: { type: 'integer' },
+      },
+    },
+    Session: {
+      type: 'object',
+      properties: {
+        session_id: { type: 'string' },
+        server_name: { type: 'string' },
+        created_at: { type: 'string' },
+        last_request_at: { type: 'string' },
+      },
+    },
+    Conversation: {
+      type: 'object',
+      properties: {
+        conversation_id: { type: 'string' },
+        session_id: { type: 'string' },
+        created_at: { type: 'string' },
+      },
+    },
+    Statistics: {
+      type: 'object',
+      properties: {
+        totalRequests: { type: 'integer' },
+        totalSessions: { type: 'integer' },
+        totalConversations: { type: 'integer' },
+        requestsByMethod: { type: 'object' },
+        requestsByStatus: { type: 'object' },
+      },
+    },
+    LogEntry: {
+      type: 'object',
+      properties: {
+        timestamp: { type: 'string' },
+        type: { type: 'string' },
+        line: { type: 'string' },
+      },
+    },
+    Backup: {
+      type: 'object',
+      properties: {
+        backupPath: { type: 'string' },
+        originalPath: { type: 'string' },
+        createdAt: { type: 'string' },
+      },
+    },
+    Scan: {
+      type: 'object',
+      properties: {
+        scanId: { type: 'string' },
+        serverName: { type: 'string' },
+        status: { type: 'string' },
+        createdAt: { type: 'string' },
+        results: { type: 'object' },
+      },
+    },
+  },
+};

package/ui/server/swagger/paths/config.js

@@ -0,0 +1,117 @@
+/**
+ * Config endpoints - Configuration file management
+ */
+
+export const configPaths = {
+  '/api/config/services': {
+    post: {
+      tags: ['Config'],
+      summary: 'Extract services from config',
+      description: 'Extract MCP server configurations from a config file',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                filePath: { type: 'string', description: 'Path to config file' },
+                fileContent: { type: 'string', description: 'Config file content' },
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        200: {
+          description: 'Extracted services',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  services: {
+                    type: 'array',
+                    items: { type: 'string' },
+                  },
+                },
+              },
+            },
+          },
+        },
+        400: {
+          description: 'Bad request',
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/config/read': {
+    get: {
+      tags: ['Config'],
+      summary: 'Read config file',
+      description: 'Read and parse a configuration file',
+      parameters: [
+        {
+          name: 'filePath',
+          in: 'query',
+          required: true,
+          description: 'Path to config file',
+          schema: { type: 'string' },
+        },
+      ],
+      responses: {
+        200: {
+          description: 'Config file content',
+          content: {
+            'application/json': {
+              schema: { type: 'object' },
+            },
+          },
+        },
+        404: {
+          description: 'File not found',
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/config/detect': {
+    get: {
+      tags: ['Config'],
+      summary: 'Detect config files',
+      description: 'Detect MCP configuration files in common locations',
+      responses: {
+        200: {
+          description: 'List of detected config files',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  configs: {
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      properties: {
+                        path: { type: 'string' },
+                        editor: { type: 'string' },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+};

package/ui/server/swagger/paths/conversations.js

@@ -0,0 +1,29 @@
+/**
+ * Conversations endpoints - Conversation tracking and analysis
+ */
+
+export const conversationsPaths = {
+  '/api/conversations': {
+    get: {
+      tags: ['Conversations'],
+      summary: 'Get all conversations',
+      description: 'Retrieve a list of all tracked conversations',
+      responses: {
+        200: {
+          description: 'List of conversations',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'array',
+                items: { $ref: '#/components/schemas/Conversation' },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+};

package/ui/server/swagger/paths/help.js

@@ -0,0 +1,82 @@
+/**
+ * Help endpoints - Help and tour management
+ */
+
+export const helpPaths = {
+  '/api/help/state': {
+    get: {
+      tags: ['Help'],
+      summary: 'Get help tour state',
+      description: 'Get the current state of the help tour (dismissed/completed)',
+      responses: {
+        200: {
+          description: 'Tour state',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  dismissed: { type: 'boolean' },
+                  tourCompleted: { type: 'boolean' },
+                },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/help/dismiss': {
+    post: {
+      tags: ['Help'],
+      summary: 'Dismiss help tour',
+      description: 'Mark the help tour as dismissed',
+      responses: {
+        200: {
+          description: 'Tour dismissed',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  success: { type: 'boolean' },
+                },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+  '/api/help/reset': {
+    post: {
+      tags: ['Help'],
+      summary: 'Reset help tour',
+      description: 'Reset the help tour state to show it again',
+      responses: {
+        200: {
+          description: 'Tour reset',
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  success: { type: 'boolean' },
+                },
+              },
+            },
+          },
+        },
+        500: {
+          description: 'Internal server error',
+        },
+      },
+    },
+  },
+};