@mcp-shark/mcp-shark 1.5.4 → 1.5.6

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

@@ -1,54 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-
-export function deleteBackup(req, res, mcpSharkLogs, broadcastLogUpdate) {
-  try {
-    const { backupPath } = req.body;
-
-    if (!backupPath) {
-      return res.status(400).json({ error: 'backupPath is required' });
-    }
-
-    const resolvedBackupPath = backupPath.startsWith('~')
-      ? path.join(homedir(), backupPath.slice(1))
-      : backupPath;
-
-    if (!fs.existsSync(resolvedBackupPath)) {
-      return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-    }
-
-    fs.unlinkSync(resolvedBackupPath);
-
-    const timestamp = new Date().toISOString();
-    const deleteLog = {
-      timestamp,
-      type: 'stdout',
-      line: `[DELETE] Deleted backup: ${resolvedBackupPath.replace(homedir(), '~')}`,
-    };
-    mcpSharkLogs.push(deleteLog);
-    if (mcpSharkLogs.length > 10000) {
-      mcpSharkLogs.shift();
-    }
-    broadcastLogUpdate(deleteLog);
-
-    res.json({
-      success: true,
-      message: 'Backup file deleted successfully',
-      backupPath: resolvedBackupPath.replace(homedir(), '~'),
-    });
-  } catch (error) {
-    const timestamp = new Date().toISOString();
-    const errorLog = {
-      timestamp,
-      type: 'error',
-      line: `[DELETE ERROR] Failed to delete backup: ${error.message}`,
-    };
-    mcpSharkLogs.push(errorLog);
-    if (mcpSharkLogs.length > 10000) {
-      mcpSharkLogs.shift();
-    }
-    broadcastLogUpdate(errorLog);
-    res.status(500).json({ error: 'Failed to delete backup', details: error.message });
-  }
-}

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

@@ -1,75 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-
-export function listBackups(_req, res) {
-  try {
-    const backups = [];
-    const homeDir = homedir();
-
-    const commonPaths = [
-      path.join(homeDir, '.cursor', 'mcp.json'),
-      path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
-    ];
-
-    const backupDirs = [path.join(homeDir, '.cursor'), path.join(homeDir, '.codeium', 'windsurf')];
-
-    // Find backups with new format: .mcp.json-mcpshark.<datetime>.json
-    backupDirs.forEach((dir) => {
-      if (fs.existsSync(dir)) {
-        const files = fs.readdirSync(dir);
-        files
-          .filter((file) => {
-            // Match pattern: .<basename>-mcpshark.<datetime>.json
-            return /^\.(.+)-mcpshark\.\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.json$/.test(file);
-          })
-          .forEach((file) => {
-            const backupPath = path.join(dir, file);
-            // Extract original filename from backup name
-            // .mcp.json-mcpshark.<datetime>.json -> mcp.json
-            const match = file.match(/^\.(.+)-mcpshark\./);
-            if (match) {
-              const originalBasename = match[1];
-              const originalPath = path.join(dir, originalBasename);
-              const stats = fs.statSync(backupPath);
-              backups.push({
-                originalPath: originalPath,
-                backupPath: backupPath,
-                createdAt: stats.birthtime.toISOString(),
-                modifiedAt: stats.mtime.toISOString(),
-                size: stats.size,
-                displayPath: originalPath.replace(homeDir, '~'),
-                backupFileName: file,
-              });
-            }
-          });
-      }
-    });
-
-    // Also check for old .backup format for backward compatibility
-    commonPaths.forEach((configPath) => {
-      const backupPath = `${configPath}.backup`;
-      if (fs.existsSync(backupPath)) {
-        const stats = fs.statSync(backupPath);
-        backups.push({
-          originalPath: configPath,
-          backupPath: backupPath,
-          createdAt: stats.birthtime.toISOString(),
-          modifiedAt: stats.mtime.toISOString(),
-          size: stats.size,
-          displayPath: configPath.replace(homeDir, '~'),
-          backupFileName: path.basename(backupPath),
-        });
-      }
-    });
-
-    // Sort by modifiedAt (latest first)
-    res.json({
-      backups: backups.sort(
-        (a, b) => new Date(b.modifiedAt || b.createdAt) - new Date(a.modifiedAt || a.createdAt)
-      ),
-    });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to list backups', details: error.message });
-  }
-}

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

@@ -1,83 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-
-export function restoreBackup(req, res, mcpSharkLogs, broadcastLogUpdate) {
-  try {
-    const { backupPath, originalPath } = req.body;
-
-    if (!backupPath) {
-      return res.status(400).json({ error: 'backupPath is required' });
-    }
-
-    const resolvedBackupPath = backupPath.startsWith('~')
-      ? path.join(homedir(), backupPath.slice(1))
-      : backupPath;
-
-    if (!fs.existsSync(resolvedBackupPath)) {
-      return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-    }
-
-    // Determine original path
-    const determineTargetPath = (originalPath, backupPath) => {
-      if (originalPath) {
-        return originalPath.startsWith('~')
-          ? path.join(homedir(), originalPath.slice(1))
-          : originalPath;
-      }
-
-      // Try to extract from backup filename
-      if (backupPath.endsWith('.backup')) {
-        return backupPath.replace('.backup', '');
-      }
-
-      // New format: .mcp.json-mcpshark.<datetime>.json
-      const match = path.basename(backupPath).match(/^\.(.+)-mcpshark\./);
-      if (match) {
-        const originalBasename = match[1];
-        return path.join(path.dirname(backupPath), originalBasename);
-      }
-
-      return null;
-    };
-
-    const targetPath = determineTargetPath(originalPath, resolvedBackupPath);
-    if (!targetPath) {
-      return res.status(400).json({ error: 'Could not determine original file path' });
-    }
-
-    const backupContent = fs.readFileSync(resolvedBackupPath, 'utf8');
-    fs.writeFileSync(targetPath, backupContent);
-
-    const timestamp = new Date().toISOString();
-    const restoreLog = {
-      timestamp,
-      type: 'stdout',
-      line: `[RESTORE] Restored config from backup: ${targetPath.replace(homedir(), '~')}`,
-    };
-    mcpSharkLogs.push(restoreLog);
-    if (mcpSharkLogs.length > 10000) {
-      mcpSharkLogs.shift();
-    }
-    broadcastLogUpdate(restoreLog);
-
-    res.json({
-      success: true,
-      message: 'Config file restored from backup',
-      originalPath: targetPath.replace(homedir(), '~'),
-    });
-  } catch (error) {
-    const timestamp = new Date().toISOString();
-    const errorLog = {
-      timestamp,
-      type: 'error',
-      line: `[RESTORE ERROR] Failed to restore: ${error.message}`,
-    };
-    mcpSharkLogs.push(errorLog);
-    if (mcpSharkLogs.length > 10000) {
-      mcpSharkLogs.shift();
-    }
-    broadcastLogUpdate(errorLog);
-    res.status(500).json({ error: 'Failed to restore backup', details: error.message });
-  }
-}

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

@@ -1,47 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-
-function tryParseJson(content) {
-  try {
-    return JSON.parse(content);
-  } catch (_e) {
-    return null;
-  }
-}
-
-export function viewBackup(req, res) {
-  try {
-    const { backupPath } = req.query;
-
-    if (!backupPath) {
-      return res.status(400).json({ error: 'backupPath is required' });
-    }
-
-    const resolvedBackupPath = backupPath.startsWith('~')
-      ? path.join(homedir(), backupPath.slice(1))
-      : backupPath;
-
-    if (!fs.existsSync(resolvedBackupPath)) {
-      return res.status(404).json({ error: 'Backup file not found', path: resolvedBackupPath });
-    }
-
-    const content = fs.readFileSync(resolvedBackupPath, 'utf-8');
-    const parsed = tryParseJson(content);
-
-    const stats = fs.statSync(resolvedBackupPath);
-
-    res.json({
-      success: true,
-      backupPath: resolvedBackupPath,
-      displayPath: resolvedBackupPath.replace(homedir(), '~'),
-      content: content,
-      parsed: parsed,
-      createdAt: stats.birthtime.toISOString(),
-      modifiedAt: stats.mtime.toISOString(),
-      size: stats.size,
-    });
-  } catch (error) {
-    res.status(500).json({ error: 'Failed to read backup file', details: error.message });
-  }
-}

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

@@ -1,129 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-import { startMcpSharkServer } from '@mcp-shark/mcp-shark/mcp-server';
-import { getMcpConfigPath } from '#common/configs';
-import { getSelectedServiceNames, updateConfigFile } from '../../utils/config-update.js';
-import { clearOriginalConfig, convertMcpServersToServers } from '../../utils/config.js';
-import logger from '../../utils/logger.js';
-import { createLogEntry } from '../../utils/process.js';
-import { filterServers, parseJsonConfig, resolveFileData } from './utils.js';
-
-const MAX_LOG_LINES = 10000;
-
-export async function setup(
-  req,
-  res,
-  getMcpSharkProcess,
-  setMcpSharkProcess,
-  mcpSharkLogs,
-  broadcastLogUpdate
-) {
-  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 = resolveFileData(filePath, fileContent);
-
-    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 = parseJsonConfig(fileData.content);
-
-    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;
-    const baseConvertedConfig = convertMcpServersToServers(originalConfig);
-
-    const convertedConfig =
-      selectedServices && Array.isArray(selectedServices) && selectedServices.length > 0
-        ? filterServers(baseConvertedConfig, selectedServices)
-        : baseConvertedConfig;
-
-    if (Object.keys(convertedConfig.servers).length === 0) {
-      return res.status(400).json({ error: 'No servers found in config' });
-    }
-
-    const mcpsJsonPath = getMcpConfigPath();
-    fs.writeFileSync(mcpsJsonPath, JSON.stringify(convertedConfig, null, 2));
-    logger.info({ path: mcpsJsonPath }, 'Wrote converted config');
-
-    const currentServer = getMcpSharkProcess();
-    if (currentServer?.stop) {
-      await currentServer.stop();
-      setMcpSharkProcess(null);
-    }
-
-    logEntry('info', '[UI Server] Starting MCP-Shark server as library...');
-    logEntry('info', `[UI Server] Config: ${mcpsJsonPath}`);
-
-    const serverInstance = await startMcpSharkServer({
-      configPath: mcpsJsonPath,
-      port: 9851,
-      onError: (err) => {
-        logEntry('error', `Failed to start mcp-shark server: ${err.message}`);
-        setMcpSharkProcess(null);
-        throw err;
-      },
-      onReady: () => {
-        logEntry('info', 'MCP Shark server is ready!');
-        logger.info('MCP Shark server is ready!');
-      },
-    });
-
-    setMcpSharkProcess(serverInstance);
-    logger.info('MCP Shark server started successfully');
-
-    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 (error) {
-    logger.error({ error: error.message }, 'Error setting up mcp-shark server');
-    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 });
-  }
-}

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

@@ -1,7 +0,0 @@
-export function getStatus(_req, res, getMcpSharkProcess) {
-  const currentServer = getMcpSharkProcess();
-  res.json({
-    running: currentServer !== null,
-    pid: null, // No process PID when using library
-  });
-}

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

@@ -1,39 +0,0 @@
-export async function stop(
-  _req,
-  res,
-  restoreOriginalConfig,
-  getMcpSharkProcess,
-  setMcpSharkProcess,
-  mcpSharkLogs,
-  broadcastLogUpdate
-) {
-  try {
-    const currentServer = getMcpSharkProcess();
-    if (currentServer?.stop) {
-      await currentServer.stop();
-      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 > 10000) {
-          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 });
-  }
-}

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

@@ -1,45 +0,0 @@
-import * as fs from 'node:fs';
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-
-export function resolveFileData(filePath, fileContent) {
-  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,
-  };
-}
-
-export function parseJsonConfig(content) {
-  try {
-    return { config: JSON.parse(content), error: null };
-  } catch (e) {
-    return { config: null, error: e };
-  }
-}
-
-export function filterServers(config, services) {
-  const filteredServers = {};
-  services.forEach((serviceName) => {
-    if (config.servers[serviceName]) {
-      filteredServers[serviceName] = config.servers[serviceName];
-    }
-  });
-  return { servers: filteredServers };
-}

package/ui/server/routes/smartscan/discover.js

@@ -1,118 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { getMcpConfigPath } from '#common/configs';
-import { convertMcpServersToServers } from '../../utils/config.js';
-import logger from '../../utils/logger.js';
-import { createTransport } from './transport.js';
-
-/**
- * Discover a single MCP server
- */
-async function discoverServer(serverName, serverConfig) {
-  const transport = createTransport(serverConfig, serverName);
-  const client = new Client(
-    { name: 'mcp-shark-smart-scan', version: '1.0.0' },
-    {
-      capabilities: {
-        tools: {},
-        resources: {},
-        prompts: {},
-      },
-    }
-  );
-
-  try {
-    await client.connect(transport);
-
-    const [toolsResult, resourcesResult, promptsResult] = await Promise.allSettled([
-      client.listTools(),
-      client.listResources(),
-      client.listPrompts(),
-    ]);
-
-    const tools = toolsResult.status === 'fulfilled' ? toolsResult.value?.tools || [] : [];
-    const resources =
-      resourcesResult.status === 'fulfilled' ? resourcesResult.value?.resources || [] : [];
-    const prompts = promptsResult.status === 'fulfilled' ? promptsResult.value?.prompts || [] : [];
-
-    await client.close();
-    if (transport.close) {
-      await transport.close();
-    }
-
-    return {
-      name: serverName,
-      tools,
-      resources,
-      prompts,
-    };
-  } catch (error) {
-    try {
-      await client.close();
-      if (transport.close) {
-        await transport.close();
-      }
-    } catch (_closeError) {
-      // Ignore close errors
-    }
-    throw error;
-  }
-}
-
-/**
- * Discover all MCP servers from config
- * GET /api/smartscan/discover
- */
-export async function discoverServers(_req, res) {
-  try {
-    const configPath = getMcpConfigPath();
-
-    if (!existsSync(configPath)) {
-      return res.status(404).json({
-        error: 'MCP config file not found',
-        message: `Config file not found at: ${configPath}`,
-      });
-    }
-
-    const configContent = readFileSync(configPath, 'utf-8');
-    const parsedConfig = JSON.parse(configContent);
-
-    const convertedConfig = convertMcpServersToServers(parsedConfig);
-    const servers = convertedConfig.servers || {};
-
-    if (Object.keys(servers).length === 0) {
-      return res.status(400).json({
-        error: 'No servers found in config',
-        message: 'The config file does not contain any MCP servers',
-      });
-    }
-
-    const discoveryPromises = Object.entries(servers).map(async ([serverName, serverConfig]) => {
-      try {
-        return await discoverServer(serverName, serverConfig);
-      } catch (error) {
-        logger.error({ serverName, error: error.message }, 'Error discovering server');
-        return {
-          name: serverName,
-          tools: [],
-          resources: [],
-          prompts: [],
-          error: error.message,
-        };
-      }
-    });
-
-    const discoveredServers = await Promise.all(discoveryPromises);
-
-    return res.json({
-      success: true,
-      servers: discoveredServers,
-    });
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error discovering servers');
-    return res.status(500).json({
-      error: 'Failed to discover servers',
-      message: error.message,
-    });
-  }
-}

package/ui/server/routes/smartscan/scans/clearCache.js

@@ -1,23 +0,0 @@
-import logger from '../../../utils/logger.js';
-import { clearAllScanResults } from '../../../utils/scan-cache.js';
-
-/**
- * Clear all cached scan results
- * POST /api/smartscan/cache/clear
- */
-export function clearCache(_req, res) {
-  try {
-    const deletedCount = clearAllScanResults();
-    return res.json({
-      success: true,
-      message: `Cleared ${deletedCount} cached scan result${deletedCount !== 1 ? 's' : ''}`,
-      deletedCount,
-    });
-  } catch (error) {
-    logger.error({ error: error.message }, 'Error clearing cache');
-    return res.status(500).json({
-      error: 'Failed to clear cache',
-      message: error.message,
-    });
-  }
-}