@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/ui/server/routes/config.js

@@ -1,179 +1,20 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-import { extractServices } from '../utils/config.js';
-import { createBackupRoutes } from './backups/index.js';
+import { ConfigController } from '#ui/server/controllers/index.js';
 
-function readFileContent(filePath) {
-  const resolvedFilePath = filePath.startsWith('~')
-    ? path.join(homedir(), filePath.slice(1))
-    : filePath;
+/**
+ * Create config routes
+ * Routes delegate to ConfigController which calls ConfigService
+ */
+export function createConfigRoutes(container) {
+  const configService = container.getService('config');
+  const logger = container.getLibrary('logger');
+  const configController = new ConfigController(configService, logger);
 
-  if (!fs.existsSync(resolvedFilePath)) {
-    return null;
-  }
-  return fs.readFileSync(resolvedFilePath, 'utf-8');
-}
-
-function parseJsonSafely(content) {
-  try {
-    return { config: JSON.parse(content), error: null };
-  } catch (e) {
-    return { config: null, error: e };
-  }
-}
-
-function tryParseJson(content) {
-  try {
-    return JSON.parse(content);
-  } catch (_e) {
-    return null;
-  }
-}
-
-export function createConfigRoutes() {
   const router = {};
 
-  router.extractServices = (req, res) => {
-    try {
-      const { filePath, fileContent } = req.body;
-
-      if (!filePath && !fileContent) {
-        return res.status(400).json({ error: 'Either filePath or fileContent is required' });
-      }
-
-      const content = fileContent ? fileContent : readFileContent(filePath);
-
-      if (!content) {
-        const resolvedFilePath = filePath.startsWith('~')
-          ? path.join(homedir(), filePath.slice(1))
-          : filePath;
-        return res.status(404).json({ error: 'File not found', path: resolvedFilePath });
-      }
-
-      const parseResult = parseJsonSafely(content);
-
-      if (!parseResult.config) {
-        return res.status(400).json({
-          error: 'Invalid JSON file',
-          details: parseResult.error ? parseResult.error.message : 'Failed to parse JSON',
-        });
-      }
-
-      const config = parseResult.config;
-
-      const services = extractServices(config);
-      res.json({ success: true, services });
-    } catch (error) {
-      res.status(500).json({ error: 'Failed to extract services', details: error.message });
-    }
-  };
-
-  router.readConfig = (req, res) => {
-    try {
-      const { filePath } = req.query;
-
-      if (!filePath) {
-        return res.status(400).json({ error: 'filePath is required' });
-      }
-
-      const resolvedPath = filePath.startsWith('~')
-        ? path.join(homedir(), filePath.slice(1))
-        : filePath;
-
-      if (!fs.existsSync(resolvedPath)) {
-        return res.status(404).json({ error: 'File not found', path: resolvedPath });
-      }
-
-      const content = fs.readFileSync(resolvedPath, 'utf-8');
-      const parsed = tryParseJson(content);
-
-      res.json({
-        success: true,
-        filePath: resolvedPath,
-        displayPath: resolvedPath.replace(homedir(), '~'),
-        content: content,
-        parsed: parsed,
-        exists: true,
-      });
-    } catch (error) {
-      res.status(500).json({ error: 'Failed to read file', details: error.message });
-    }
-  };
-
-  router.detectConfig = (_req, res) => {
-    const detected = [];
-    const platform = process.platform;
-    const homeDir = homedir();
-
-    const cursorPaths = [
-      path.join(homeDir, '.cursor', 'mcp.json'),
-      ...(platform === 'win32'
-        ? [path.join(process.env.USERPROFILE || '', '.cursor', 'mcp.json')]
-        : []),
-    ];
-
-    const windsurfPaths = [
-      path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
-      ...(platform === 'win32'
-        ? [path.join(process.env.USERPROFILE || '', '.codeium', 'windsurf', 'mcp_config.json')]
-        : []),
-    ];
-
-    for (const cursorPath of cursorPaths) {
-      if (fs.existsSync(cursorPath)) {
-        detected.push({
-          editor: 'Cursor',
-          path: cursorPath,
-          displayPath: cursorPath.replace(homeDir, '~'),
-          exists: true,
-        });
-        break;
-      }
-    }
-
-    for (const windsurfPath of windsurfPaths) {
-      if (fs.existsSync(windsurfPath)) {
-        detected.push({
-          editor: 'Windsurf',
-          path: windsurfPath,
-          displayPath: windsurfPath.replace(homeDir, '~'),
-          exists: true,
-        });
-        break;
-      }
-    }
-
-    const defaultPaths = [
-      {
-        editor: 'Cursor',
-        path: path.join(homeDir, '.cursor', 'mcp.json'),
-        displayPath: '~/.cursor/mcp.json',
-        exists: fs.existsSync(path.join(homeDir, '.cursor', 'mcp.json')),
-      },
-      {
-        editor: 'Windsurf',
-        path: path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
-        displayPath: '~/.codeium/windsurf/mcp_config.json',
-        exists: fs.existsSync(path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json')),
-      },
-    ];
-
-    const result = detected.length > 0 ? detected : defaultPaths;
-
-    res.json({
-      detected: result,
-      platform,
-      homeDir,
-    });
-  };
-
-  // Delegate backup routes to separate module
-  const backupRoutes = createBackupRoutes();
-  router.listBackups = backupRoutes.listBackups;
-  router.restoreBackup = backupRoutes.restoreBackup;
-  router.viewBackup = backupRoutes.viewBackup;
-  router.deleteBackup = backupRoutes.deleteBackup;
+  // Delegate to controller
+  router.extractServices = configController.extractServices;
+  router.readConfig = configController.readConfig;
+  router.detectConfig = configController.detectConfig;
 
   return router;
 }

package/ui/server/routes/conversations.js

@@ -1,25 +1,15 @@
-import { queryConversations } from '#common/db/query';
-import { serializeBigInt } from '../utils/serialization.js';
+import { ConversationController } from '../controllers/ConversationController.js';
+
+export function createConversationsRoutes(container) {
+  const conversationService = container.getService('conversation');
+  const serializationLib = container.getLibrary('serialization');
+  const logger = container.getLibrary('logger');
+
+  const controller = new ConversationController(conversationService, serializationLib, logger);
 
-export function createConversationsRoutes(db) {
   const router = {};
 
-  router.getConversations = (req, res) => {
-    const limit = Number.parseInt(req.query.limit) || 1000;
-    const offset = Number.parseInt(req.query.offset) || 0;
-    const filters = {
-      sessionId: req.query.sessionId || null,
-      method: req.query.method || null,
-      status: req.query.status || null,
-      jsonrpcId: req.query.jsonrpcId || null,
-      startTime: req.query.startTime ? BigInt(req.query.startTime) : null,
-      endTime: req.query.endTime ? BigInt(req.query.endTime) : null,
-      limit,
-      offset,
-    };
-    const conversations = queryConversations(db, filters);
-    res.json(serializeBigInt(conversations));
-  };
+  router.getConversations = (req, res) => controller.getConversations(req, res);
 
   return router;
 }

package/ui/server/routes/help.js

@@ -1,4 +1,5 @@
-import { readHelpState, writeHelpState } from '#common/configs';
+import { readHelpState, writeHelpState } from '#core/configs/index.js';
+import { StatusCodes } from '#core/constants/index.js';
 
 export function createHelpRoutes() {
   const router = {};
@@ -21,7 +22,7 @@ export function createHelpRoutes() {
     if (success) {
       res.json({ success: true });
     } else {
-      res.status(500).json({ error: 'Failed to save help state' });
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: 'Failed to save help state' });
     }
   };
 
@@ -35,7 +36,7 @@ export function createHelpRoutes() {
     if (success) {
       res.json({ success: true });
     } else {
-      res.status(500).json({ error: 'Failed to reset help state' });
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: 'Failed to reset help state' });
     }
   };
 

package/ui/server/routes/logs.js

@@ -1,32 +1,20 @@
-export function createLogsRoutes(mcpSharkLogs, _broadcastLogUpdate) {
-  const router = {};
-
-  router.getLogs = (req, res) => {
-    const limit = Number.parseInt(req.query.limit) || 1000;
-    const offset = Number.parseInt(req.query.offset) || 0;
-    const logs = [...mcpSharkLogs].reverse().slice(offset, offset + limit);
-    res.json(logs);
-  };
+import { LogController } from '#ui/server/controllers/index.js';
 
-  router.clearLogs = (_req, res) => {
-    mcpSharkLogs.length = 0;
-    res.json({ success: true, message: 'Logs cleared' });
-  };
+/**
+ * Create logs routes
+ * Routes delegate to LogController which calls LogService
+ */
+export function createLogsRoutes(container, mcpSharkLogs) {
+  const logService = container.getService('log');
+  const logger = container.getLibrary('logger');
+  logService.initialize(mcpSharkLogs);
+  const logController = new LogController(logService, logger);
 
-  router.exportLogs = (_req, res) => {
-    try {
-      const logsText = mcpSharkLogs
-        .map((log) => `[${log.timestamp}] [${log.type.toUpperCase()}] ${log.line}`)
-        .join('\n');
+  const router = {};
 
-      const filename = `mcp-shark-logs-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`;
-      res.setHeader('Content-Type', 'text/plain');
-      res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
-      res.send(logsText);
-    } catch (error) {
-      res.status(500).json({ error: 'Failed to export logs', details: error.message });
-    }
-  };
+  router.getLogs = logController.getLogs;
+  router.clearLogs = logController.clearLogs;
+  router.exportLogs = logController.exportLogs;
 
   return router;
 }

package/ui/server/routes/playground.js

@@ -1,181 +1,18 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import logger from '../utils/logger.js';
+import { McpClientController } from '#ui/server/controllers/index.js';
 
-const MCP_SERVER_BASE_URL = 'http://localhost:9851/mcp';
+/**
+ * Create playground routes
+ * Routes delegate to McpClientController which calls McpClientService
+ */
+export function createPlaygroundRoutes(container) {
+  const mcpClientService = container.getService('mcpClient');
+  const logger = container.getLibrary('logger');
+  const mcpClientController = new McpClientController(mcpClientService, logger);
 
-// Store client connections per server and session
-const clientSessions = new Map();
-
-function getSessionKey(serverName, sessionId) {
-  return `${serverName}:${sessionId}`;
-}
-
-export function createPlaygroundRoutes() {
   const router = {};
 
-  // Get or create client for a session and server
-  async function getClient(serverName, sessionId) {
-    const sessionKey = getSessionKey(serverName, sessionId);
-    if (clientSessions.has(sessionKey)) {
-      return clientSessions.get(sessionKey);
-    }
-
-    if (!serverName) {
-      throw new Error('Server name is required');
-    }
-
-    const mcpServerUrl = `${MCP_SERVER_BASE_URL}/${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,
-      close: async () => {
-        await client.close();
-        transport.close?.();
-      },
-    };
-
-    clientSessions.set(sessionKey, clientWrapper);
-    return clientWrapper;
-  }
-
-  router.proxyRequest = async (req, res) => {
-    try {
-      const { method, params, serverName } = req.body;
-
-      if (!method) {
-        return res.status(400).json({
-          error: 'Invalid request',
-          message: 'method field is required',
-        });
-      }
-
-      if (!serverName) {
-        return res.status(400).json({
-          error: 'Invalid request',
-          message: 'serverName field is required',
-        });
-      }
-
-      // Get or create session ID
-      const sessionId =
-        req.headers['mcp-session-id'] ||
-        req.headers['x-mcp-session-id'] ||
-        `playground-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-
-      const { client } = await getClient(serverName, sessionId);
-
-      const executeMethod = async () => {
-        switch (method) {
-          case 'tools/list':
-            return await client.listTools();
-          case 'tools/call':
-            if (!params?.name) {
-              return res.status(400).json({
-                error: 'Invalid request',
-                message: '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) {
-              return res.status(400).json({
-                error: 'Invalid request',
-                message: '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) {
-              return res.status(400).json({
-                error: 'Invalid request',
-                message: 'Resource URI is required',
-              });
-            }
-            return await client.readResource({ uri: params.uri });
-          default:
-            return res.status(400).json({
-              error: 'Unsupported method',
-              message: `Method ${method} is not supported`,
-            });
-        }
-      };
-
-      const result = await executeMethod();
-
-      // Return session ID in response
-      res.setHeader('Mcp-Session-Id', sessionId);
-      res.json({
-        result,
-        _sessionId: sessionId,
-      });
-    } catch (error) {
-      logger.error({ error: error.message }, 'Error in playground proxy');
-
-      // Check if it's a connection error
-      if (error.message?.includes('ECONNREFUSED') || error.message?.includes('connect')) {
-        return res.status(503).json({
-          error: 'MCP server unavailable',
-          message: error.message,
-          details: 'Make sure the MCP Shark server is running on port 9851',
-        });
-      }
-
-      res.status(500).json({
-        error: 'Internal server error',
-        message: error.message || 'Unknown error',
-      });
-    }
-  };
-
-  // Cleanup endpoint to close client connections
-  router.cleanup = async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'] || req.headers['x-mcp-session-id'];
-    const { serverName } = req.body || {};
-
-    if (serverName && sessionId) {
-      const sessionKey = getSessionKey(serverName, sessionId);
-      if (clientSessions.has(sessionKey)) {
-        const clientWrapper = clientSessions.get(sessionKey);
-        await clientWrapper.close();
-        clientSessions.delete(sessionKey);
-      }
-    } else if (sessionId) {
-      // Cleanup all sessions for this sessionId across all servers
-      for (const [key, clientWrapper] of clientSessions.entries()) {
-        if (key.endsWith(`:${sessionId}`)) {
-          await clientWrapper.close();
-          clientSessions.delete(key);
-        }
-      }
-    }
-    res.json({ success: true });
-  };
+  router.proxyRequest = mcpClientController.proxyRequest;
+  router.cleanup = mcpClientController.cleanup;
 
   return router;
 }