@mcp-shark/mcp-shark 1.4.0

package/ui/server/routes/composite.js

@@ -0,0 +1,244 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { homedir } from 'node:os';
+import { checkPortReady } from '../utils/port.js';
+import { findMcpServerPath } from '../utils/paths.js';
+import { convertMcpServersToServers, clearOriginalConfig } from '../utils/config.js';
+import { getMcpConfigPath } from 'mcp-shark-common/configs/index.js';
+import {
+  createLogEntry,
+  spawnMcpSharkServer,
+  setupProcessHandlers,
+  getMcpSharkJsPath,
+} from '../utils/process.js';
+import { updateConfigFile, getSelectedServiceNames } from '../utils/config-update.js';
+
+const MAX_LOG_LINES = 10000;
+
+export function createCompositeRoutes(
+  getMcpSharkProcess,
+  setMcpSharkProcess,
+  mcpSharkLogs,
+  broadcastLogUpdate
+) {
+  const router = {};
+
+  router.setup = async (req, res) => {
+    mcpSharkLogs.length = 0;
+    const logEntry = createLogEntry(mcpSharkLogs, broadcastLogUpdate);
+
+    try {
+      const { filePath, fileContent, selectedServices } = req.body;
+
+      if (!filePath && !fileContent) {
+        return res.status(400).json({ error: 'Either filePath or fileContent is required' });
+      }
+
+      const fileData = (() => {
+        if (fileContent) {
+          const resolvedFilePath = filePath
+            ? filePath.startsWith('~')
+              ? path.join(homedir(), filePath.slice(1))
+              : filePath
+            : null;
+          return { content: fileContent, resolvedFilePath };
+        }
+
+        const resolvedFilePath = filePath.startsWith('~')
+          ? path.join(homedir(), filePath.slice(1))
+          : filePath;
+
+        if (!fs.existsSync(resolvedFilePath)) {
+          return null;
+        }
+
+        return {
+          content: fs.readFileSync(resolvedFilePath, 'utf-8'),
+          resolvedFilePath,
+        };
+      })();
+
+      if (!fileData) {
+        const resolvedFilePath = filePath.startsWith('~')
+          ? path.join(homedir(), filePath.slice(1))
+          : filePath;
+        return res.status(404).json({ error: 'File not found', path: resolvedFilePath });
+      }
+
+      const parseResult = (() => {
+        try {
+          return { config: JSON.parse(fileData.content), error: null };
+        } catch (e) {
+          return { config: null, error: e };
+        }
+      })();
+
+      if (!parseResult.config) {
+        return res.status(400).json({
+          error: 'Invalid JSON file',
+          details: parseResult.error ? parseResult.error.message : 'Failed to parse JSON',
+        });
+      }
+
+      const originalConfig = parseResult.config;
+      let convertedConfig = convertMcpServersToServers(originalConfig);
+
+      if (selectedServices && Array.isArray(selectedServices) && selectedServices.length > 0) {
+        const filteredServers = {};
+        selectedServices.forEach((serviceName) => {
+          if (convertedConfig.servers[serviceName]) {
+            filteredServers[serviceName] = convertedConfig.servers[serviceName];
+          }
+        });
+        convertedConfig = { servers: filteredServers };
+      }
+
+      if (Object.keys(convertedConfig.servers).length === 0) {
+        return res.status(400).json({ error: 'No servers found in config' });
+      }
+
+      const mcpServerPath = findMcpServerPath();
+      const mcpsJsonPath = getMcpConfigPath();
+      fs.writeFileSync(mcpsJsonPath, JSON.stringify(convertedConfig, null, 2));
+      console.log(`Wrote converted config to: ${mcpsJsonPath}`);
+
+      const currentProcess = getMcpSharkProcess();
+      if (currentProcess) {
+        currentProcess.kill();
+        setMcpSharkProcess(null);
+      }
+
+      const mcpSharkJsPath = getMcpSharkJsPath();
+      if (!fs.existsSync(mcpSharkJsPath)) {
+        return res.status(500).json({
+          error: 'MCP Shark server not found',
+          details: `Could not find mcp-shark.js at ${mcpSharkJsPath}`,
+        });
+      }
+
+      const processHandle = spawnMcpSharkServer(mcpSharkJsPath, mcpsJsonPath, logEntry);
+      setMcpSharkProcess(processHandle);
+
+      setupProcessHandlers(
+        processHandle,
+        logEntry,
+        (err) => {
+          setMcpSharkProcess(null);
+          return res.status(500).json({
+            error: 'Failed to start mcp-shark server',
+            details: err.message,
+          });
+        },
+        () => {
+          setMcpSharkProcess(null);
+        }
+      );
+
+      try {
+        console.log('Waiting for mcp-shark server to start on port 9851...');
+        await checkPortReady(9851, 'localhost', 15000);
+        console.log('MCP Shark server is ready!');
+
+        const selectedServiceNames = getSelectedServiceNames(originalConfig, selectedServices);
+        const { updatedConfig, backupPath: createdBackupPath } = updateConfigFile(
+          originalConfig,
+          selectedServiceNames,
+          fileData.resolvedFilePath,
+          fileData.content,
+          mcpSharkLogs,
+          broadcastLogUpdate
+        );
+
+        if (!fileData.resolvedFilePath) {
+          clearOriginalConfig();
+        }
+
+        res.json({
+          success: true,
+          message: 'MCP Shark server started successfully and config file updated',
+          convertedConfig,
+          updatedConfig,
+          filePath: fileData.resolvedFilePath || null,
+          backupPath: createdBackupPath || null,
+        });
+      } catch (waitError) {
+        console.error('MCP Shark server did not start in time:', waitError);
+        if (processHandle) {
+          processHandle.kill();
+          setMcpSharkProcess(null);
+        }
+        const timestamp = new Date().toISOString();
+        const errorLog = {
+          timestamp,
+          type: 'error',
+          line: `[ERROR] MCP Shark server failed to start: ${waitError.message}`,
+        };
+        mcpSharkLogs.push(errorLog);
+        if (mcpSharkLogs.length > MAX_LOG_LINES) {
+          mcpSharkLogs.shift();
+        }
+        broadcastLogUpdate(errorLog);
+        return res.status(500).json({
+          error: 'MCP Shark server failed to start',
+          details: waitError.message,
+        });
+      }
+    } catch (error) {
+      console.error('Error setting up mcp-shark server:', error);
+      const timestamp = new Date().toISOString();
+      const errorLog = {
+        timestamp,
+        type: 'error',
+        line: `[ERROR] Failed to setup mcp-shark server: ${error.message}`,
+      };
+      mcpSharkLogs.push(errorLog);
+      if (mcpSharkLogs.length > MAX_LOG_LINES) {
+        mcpSharkLogs.shift();
+      }
+      broadcastLogUpdate(errorLog);
+      res.status(500).json({ error: 'Failed to setup mcp-shark server', details: error.message });
+    }
+  };
+
+  router.stop = (req, res, restoreOriginalConfig) => {
+    try {
+      const currentProcess = getMcpSharkProcess();
+      if (currentProcess) {
+        currentProcess.kill();
+        setMcpSharkProcess(null);
+
+        const restored = restoreOriginalConfig();
+
+        if (restored) {
+          const timestamp = new Date().toISOString();
+          const restoreLog = {
+            timestamp,
+            type: 'stdout',
+            line: `[RESTORE] Restored original config`,
+          };
+          mcpSharkLogs.push(restoreLog);
+          if (mcpSharkLogs.length > MAX_LOG_LINES) {
+            mcpSharkLogs.shift();
+          }
+          broadcastLogUpdate(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) {
+      res.status(500).json({ error: 'Failed to stop mcp-shark server', details: error.message });
+    }
+  };
+
+  router.getStatus = (req, res) => {
+    const currentProcess = getMcpSharkProcess();
+    res.json({
+      running: currentProcess !== null,
+      pid: currentProcess?.pid || null,
+    });
+  };
+
+  return router;
+}

package/ui/server/routes/config.js

@@ -0,0 +1,175 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { homedir } from 'node:os';
+import { extractServices, convertMcpServersToServers } from '../utils/config.js';
+import { createBackupRoutes } from './backups.js';
+
+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
+        : (() => {
+            const resolvedFilePath = filePath.startsWith('~')
+              ? path.join(homedir(), filePath.slice(1))
+              : filePath;
+
+            if (!fs.existsSync(resolvedFilePath)) {
+              return null;
+            }
+            return fs.readFileSync(resolvedFilePath, 'utf-8');
+          })();
+
+      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 = (() => {
+        try {
+          return { config: JSON.parse(content), error: null };
+        } catch (e) {
+          return { config: null, error: e };
+        }
+      })();
+
+      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 = (() => {
+        try {
+          return JSON.parse(content);
+        } catch (e) {
+          return null;
+        }
+      })();
+
+      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;
+
+  return router;
+}

package/ui/server/routes/conversations.js

@@ -0,0 +1,25 @@
+import { serializeBigInt } from '../utils/serialization.js';
+import { queryConversations } from 'mcp-shark-common/db/query.js';
+
+export function createConversationsRoutes(db) {
+  const router = {};
+
+  router.getConversations = (req, res) => {
+    const limit = parseInt(req.query.limit) || 1000;
+    const offset = 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));
+  };
+
+  return router;
+}

package/ui/server/routes/help.js

@@ -0,0 +1,43 @@
+import { readHelpState, writeHelpState } from 'mcp-shark-common/configs/index.js';
+
+export function createHelpRoutes() {
+  const router = {};
+
+  router.getState = (req, res) => {
+    const state = readHelpState();
+    res.json({
+      dismissed: state.dismissed || false,
+      tourCompleted: state.tourCompleted || false,
+    });
+  };
+
+  router.dismiss = (req, res) => {
+    const { tourCompleted } = req.body || {};
+    const state = {
+      dismissed: true,
+      tourCompleted: tourCompleted || false,
+    };
+    const success = writeHelpState(state);
+    if (success) {
+      res.json({ success: true });
+    } else {
+      res.status(500).json({ error: 'Failed to save help state' });
+    }
+  };
+
+  router.reset = (req, res) => {
+    const state = {
+      dismissed: false,
+      tourCompleted: false,
+      dismissedAt: null,
+    };
+    const success = writeHelpState(state);
+    if (success) {
+      res.json({ success: true });
+    } else {
+      res.status(500).json({ error: 'Failed to reset help state' });
+    }
+  };
+
+  return router;
+}

package/ui/server/routes/logs.js

@@ -0,0 +1,32 @@
+export function createLogsRoutes(mcpSharkLogs, broadcastLogUpdate) {
+  const router = {};
+
+  router.getLogs = (req, res) => {
+    const limit = parseInt(req.query.limit) || 1000;
+    const offset = parseInt(req.query.offset) || 0;
+    const logs = [...mcpSharkLogs].reverse().slice(offset, offset + limit);
+    res.json(logs);
+  };
+
+  router.clearLogs = (req, res) => {
+    mcpSharkLogs.length = 0;
+    res.json({ success: true, message: 'Logs cleared' });
+  };
+
+  router.exportLogs = (req, res) => {
+    try {
+      const logsText = mcpSharkLogs
+        .map((log) => `[${log.timestamp}] [${log.type.toUpperCase()}] ${log.line}`)
+        .join('\n');
+
+      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 });
+    }
+  };
+
+  return router;
+}

package/ui/server/routes/playground.js

@@ -0,0 +1,152 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const MCP_SERVER_URL = 'http://localhost:9851/mcp';
+
+// Store client connections per session
+const clientSessions = new Map();
+
+export function createPlaygroundRoutes() {
+  const router = {};
+
+  // Get or create client for a session
+  async function getClient(sessionId) {
+    if (clientSessions.has(sessionId)) {
+      return clientSessions.get(sessionId);
+    }
+
+    const client = new Client(
+      { name: 'mcp-shark-playground', version: '1.0.0' },
+      {
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {},
+        },
+      }
+    );
+
+    const transport = new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL));
+    await client.connect(transport);
+
+    const clientWrapper = {
+      client,
+      transport,
+      close: async () => {
+        await client.close();
+        transport.close?.();
+      },
+    };
+
+    clientSessions.set(sessionId, clientWrapper);
+    return clientWrapper;
+  }
+
+  router.proxyRequest = async (req, res) => {
+    try {
+      const { method, params } = req.body;
+
+      if (!method) {
+        return res.status(400).json({
+          error: 'Invalid request',
+          message: 'method 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(sessionId);
+
+      let result;
+      switch (method) {
+        case 'tools/list':
+          result = await client.listTools();
+          break;
+        case 'tools/call':
+          if (!params?.name) {
+            return res.status(400).json({
+              error: 'Invalid request',
+              message: 'Tool name is required',
+            });
+          }
+          result = await client.callTool({
+            name: params.name,
+            arguments: params.arguments || {},
+          });
+          break;
+        case 'prompts/list':
+          result = await client.listPrompts();
+          break;
+        case 'prompts/get':
+          if (!params?.name) {
+            return res.status(400).json({
+              error: 'Invalid request',
+              message: 'Prompt name is required',
+            });
+          }
+          result = await client.getPrompt({
+            name: params.name,
+            arguments: params.arguments || {},
+          });
+          break;
+        case 'resources/list':
+          result = await client.listResources();
+          break;
+        case 'resources/read':
+          if (!params?.uri) {
+            return res.status(400).json({
+              error: 'Invalid request',
+              message: 'Resource URI is required',
+            });
+          }
+          result = await client.readResource({ uri: params.uri });
+          break;
+        default:
+          return res.status(400).json({
+            error: 'Unsupported method',
+            message: `Method ${method} is not supported`,
+          });
+      }
+
+      // Return session ID in response
+      res.setHeader('Mcp-Session-Id', sessionId);
+      res.json({
+        result,
+        _sessionId: sessionId,
+      });
+    } catch (error) {
+      console.error('Error in playground proxy:', error);
+
+      // 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'];
+    if (sessionId && clientSessions.has(sessionId)) {
+      const clientWrapper = clientSessions.get(sessionId);
+      await clientWrapper.close();
+      clientSessions.delete(sessionId);
+    }
+    res.json({ success: true });
+  };
+
+  return router;
+}