@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/core/services/parsers/JsonConfigParser.js

@@ -0,0 +1,66 @@
+/**
+ * Parser for standard MCP JSON configuration format
+ * Handles { mcpServers: { ... } } format (Cursor, Windsurf, etc.)
+ */
+export class JsonConfigParser {
+  /**
+   * Parse JSON content
+   * @param {string} content - JSON file content
+   * @returns {Object|null} Parsed config or null on error
+   */
+  parse(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === 'object') {
+        return parsed;
+      }
+      return null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if config is in standard MCP JSON format
+   * @param {Object} config - Parsed config object
+   * @returns {boolean} True if config has mcpServers section
+   */
+  isMcpServersFormat(config) {
+    return config && typeof config === 'object' && config.mcpServers !== undefined;
+  }
+
+  /**
+   * Normalize standard MCP JSON format to internal format
+   * Standard format: { mcpServers: { "server-name": { type?, command?, args?, env?, url?, headers? } } }
+   * Internal format: Same structure, but ensures type is set
+   * @param {Object} config - Parsed config
+   * @returns {Object|null} Normalized config or null if invalid
+   */
+  normalizeToInternalFormat(config) {
+    if (!this.isMcpServersFormat(config)) {
+      return null;
+    }
+
+    const normalized = {
+      mcpServers: {},
+    };
+
+    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+      if (!serverConfig || typeof serverConfig !== 'object') {
+        continue;
+      }
+
+      const type = serverConfig.type || (serverConfig.url ? 'http' : 'stdio');
+      normalized.mcpServers[serverName] = {
+        type,
+        ...serverConfig,
+      };
+    }
+
+    if (Object.keys(normalized.mcpServers).length === 0) {
+      return null;
+    }
+
+    return normalized;
+  }
+}

package/core/services/parsers/LegacyJsonConfigParser.js

@@ -0,0 +1,71 @@
+/**
+ * Parser for legacy MCP JSON configuration format
+ * Handles { servers: { ... } } format (old format)
+ */
+export class LegacyJsonConfigParser {
+  /**
+   * Parse JSON content
+   * @param {string} content - JSON file content
+   * @returns {Object|null} Parsed config or null on error
+   */
+  parse(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === 'object') {
+        return parsed;
+      }
+      return null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if config is in legacy format
+   * @param {Object} config - Parsed config object
+   * @returns {boolean} True if config has servers section (but not mcpServers)
+   */
+  isLegacyFormat(config) {
+    return (
+      config &&
+      typeof config === 'object' &&
+      config.servers !== undefined &&
+      config.mcpServers === undefined
+    );
+  }
+
+  /**
+   * Convert legacy format to internal format
+   * Legacy format: { servers: { "server-name": { type, command?, args?, env?, url?, headers? } } }
+   * Internal format: { servers: { "server-name": { type, ... } } }
+   * @param {Object} config - Parsed legacy config
+   * @returns {Object|null} Converted config or null if invalid
+   */
+  convertToInternalFormat(config) {
+    if (!this.isLegacyFormat(config)) {
+      return null;
+    }
+
+    const converted = {
+      servers: {},
+    };
+
+    for (const [serverName, serverConfig] of Object.entries(config.servers)) {
+      if (!serverConfig || typeof serverConfig !== 'object') {
+        continue;
+      }
+
+      const type = serverConfig.type || 'stdio';
+      converted.servers[serverName] = {
+        type,
+        ...serverConfig,
+      };
+    }
+
+    if (Object.keys(converted.servers).length === 0) {
+      return null;
+    }
+
+    return converted;
+  }
+}

package/core/services/parsers/TomlConfigParser.js

@@ -0,0 +1,87 @@
+import { parse as parseToml } from '@iarna/toml';
+
+/**
+ * Parser for TOML configuration files (Codex format)
+ * Handles [mcp_servers] section with underscore notation
+ */
+export class TomlConfigParser {
+  /**
+   * Parse TOML content
+   * @param {string} content - TOML file content
+   * @returns {Object|null} Parsed config or null on error
+   */
+  parse(content) {
+    try {
+      const parsed = parseToml(content);
+      if (parsed && typeof parsed === 'object') {
+        return parsed;
+      }
+      return null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if config is in TOML format (Codex format)
+   * @param {Object} config - Parsed config object
+   * @returns {boolean} True if config has mcp_servers section
+   */
+  isCodexFormat(config) {
+    return config && typeof config === 'object' && config.mcp_servers !== undefined;
+  }
+
+  /**
+   * Convert Codex TOML format to MCP Shark internal format
+   * Codex format: [mcp_servers."server-name"] with command, args, env, url
+   * Internal format: { mcpServers: { "server-name": { type, command, args, env, url, headers } } }
+   * @param {Object} codexConfig - Parsed Codex config
+   * @returns {Object|null} Converted config or null if invalid
+   */
+  convertToMcpSharkFormat(codexConfig) {
+    if (!this.isCodexFormat(codexConfig)) {
+      return null;
+    }
+
+    const mcpServers = {};
+
+    for (const [serverName, serverConfig] of Object.entries(codexConfig.mcp_servers)) {
+      if (!serverConfig || typeof serverConfig !== 'object') {
+        continue;
+      }
+
+      const converted = {
+        type: serverConfig.url ? 'http' : 'stdio',
+      };
+
+      if (serverConfig.command) {
+        converted.command = serverConfig.command;
+      }
+
+      if (Array.isArray(serverConfig.args)) {
+        converted.args = serverConfig.args;
+      }
+
+      if (serverConfig.env && typeof serverConfig.env === 'object') {
+        converted.env = serverConfig.env;
+      }
+
+      if (serverConfig.url) {
+        converted.url = serverConfig.url;
+        if (serverConfig.headers && typeof serverConfig.headers === 'object') {
+          converted.headers = serverConfig.headers;
+        }
+      }
+
+      mcpServers[serverName] = converted;
+    }
+
+    if (Object.keys(mcpServers).length === 0) {
+      return null;
+    }
+
+    return {
+      mcpServers,
+    };
+  }
+}

package/core/services/parsers/index.js

@@ -0,0 +1,4 @@
+export { TomlConfigParser } from './TomlConfigParser.js';
+export { JsonConfigParser } from './JsonConfigParser.js';
+export { LegacyJsonConfigParser } from './LegacyJsonConfigParser.js';
+export { ConfigParserFactory } from './ConfigParserFactory.js';

package/{ui/server → core}/utils/scan-cache/directory.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { getWorkingDirectory } from '#common/configs';
+import { getWorkingDirectory } from '#core/configs/index.js';
 
 const SCAN_RESULTS_DIR_NAME = 'scan-results';
 

package/core/utils/validation.js

@@ -0,0 +1,77 @@
+/**
+ * Input validation utilities
+ * Provides common validation functions for controllers
+ */
+
+/**
+ * Sanitize string input
+ * @param {*} value - Value to sanitize
+ * @returns {string|null} Sanitized string or null
+ */
+export function sanitizeString(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+/**
+ * Validate and parse integer
+ * @param {*} value - Value to parse
+ * @param {number} [defaultValue] - Default value if invalid
+ * @returns {number|null} Parsed integer or null/default
+ */
+export function parseInteger(value, defaultValue = null) {
+  if (value === undefined || value === null) {
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+
+/**
+ * Validate file path format
+ * @param {string} filePath - File path to validate
+ * @returns {boolean} True if path appears valid
+ */
+export function isValidFilePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    return false;
+  }
+  // Basic validation - no null bytes, reasonable length
+  if (filePath.includes('\0') || filePath.length > 4096) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Validate array input
+ * @param {*} value - Value to validate
+ * @param {number} [minLength] - Minimum array length
+ * @returns {boolean} True if valid array
+ */
+export function isValidArray(value, minLength = 0) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  return value.length >= minLength;
+}
+
+/**
+ * Validate required fields in object
+ * @param {Object} obj - Object to validate
+ * @param {string[]} requiredFields - Array of required field names
+ * @returns {{valid: boolean, missing: string[]}} Validation result
+ */
+export function validateRequiredFields(obj, requiredFields) {
+  if (!obj || typeof obj !== 'object') {
+    return { valid: false, missing: requiredFields };
+  }
+  const missing = requiredFields.filter((field) => {
+    const value = obj[field];
+    return value === undefined || value === null || value === '';
+  });
+  return { valid: missing.length === 0, missing };
+}

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@mcp-shark/mcp-shark",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "Aggregate multiple Model Context Protocol (MCP) servers into a single unified interface with a powerful monitoring UI. Prov deep visibility into every request and response.",
   "type": "module",
   "main": "./bin/mcp-shark.js",
   "exports": {
     ".": "./bin/mcp-shark.js",
-    "./mcp-server": "./mcp-server/index.js"
+    "./mcp-server": "./core/mcp-server/index.js"
   },
   "imports": {
-    "#common/configs": "./lib/common/configs/index.js",
-    "#common/db/query": "./lib/common/db/query.js",
-    "#common/db/init": "./lib/common/db/init.js",
-    "#common/db/logger": "./lib/common/db/logger.js",
-    "#common/logger": "./lib/common/logger.js",
-    "#common/*": "./lib/common/*"
+    "#core": "./core/index.js",
+    "#core/*": "./core/*",
+    "#ui/server/*": "./ui/server/*"
   },
   "bin": {
     "mcp-shark": "./bin/mcp-shark.js",
@@ -28,11 +25,11 @@
   "bugs": {
     "url": "https://github.com/mcp-shark/mcp-shark/issues"
   },
-  "files": ["bin", "ui", "mcp-server", "lib", "README.md", "LICENSE", "package.json"],
+  "files": ["bin", "ui", "core", "README.md", "LICENSE", "package.json"],
   "scripts": {
     "start": "node scripts/start-ui.js",
     "predev": "npm run build:ui",
-    "dev": "node scripts/start-ui.js'",
+    "dev": "node scripts/start-ui.js",
     "build": "bash -c 'cd ui && vite build'",
     "build:ui": "bash -c 'cd ui && vite build'",
     "lint": "biome lint .",
@@ -42,6 +39,9 @@
     "check:fix": "biome check --write .",
     "prepare": "husky install || true",
     "prepublishOnly": "npm run check:fix && npm run build:ui",
+    "pack:inspect": "npm run prepublishOnly && npm pack && tar -tzf mcp-shark-mcp-shark-*.tgz | head -50 && echo '...' && tar -tzf mcp-shark-mcp-shark-*.tgz | wc -l && echo 'files total'",
+    "pack:list": "npm run prepublishOnly && npm pack && tar -tzf mcp-shark-mcp-shark-*.tgz",
+    "pack:extract": "npm run prepublishOnly && npm pack && mkdir -p .package-inspect && tar -xzf mcp-shark-mcp-shark-*.tgz -C .package-inspect && echo 'Package extracted to .package-inspect/package/'",
     "publish:public": "npm publish --access public",
     "publish:dry-run": "npm publish --dry-run"
   },
@@ -72,18 +72,21 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
+    "@iarna/toml": "^2.2.5",
     "@modelcontextprotocol/sdk": "^1.20.2",
     "@tabler/icons-react": "^3.0.0",
     "animejs": "^3.2.2",
+    "better-sqlite3": "^12.4.1",
     "commander": "^14.0.2",
     "consola": "^3.4.2",
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "jsonrpc-lite": "^2.2.0",
-    "better-sqlite3": "^12.4.1",
     "open": "^11.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1",
     "ws": "^8.16.0"
   },
   "devDependencies": {