@mcp-shark/mcp-shark 1.5.4 → 1.5.6

package/core/mcp-server/server/external/config.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { CompositeError, isError } from '#core/libraries/ErrorLibrary.js';
+import { ConfigParserFactory } from '#core/services/parsers/ConfigParserFactory.js';
+
+const DEFAULT_TYPE = 'stdio';
+
+export class ConfigError extends CompositeError {
+  constructor(message, error) {
+    super('ConfigError', message, error);
+  }
+}
+
+const parserFactory = new ConfigParserFactory();
+
+function parseConfig(configPath) {
+  if (!existsSync(configPath)) {
+    return new ConfigError(
+      'Config file not found',
+      new Error(`Config file not found: ${configPath}`)
+    );
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = parserFactory.parse(content, configPath);
+
+    if (parsed && typeof parsed === 'object') {
+      return parsed;
+    }
+
+    return new ConfigError('Invalid config file', new Error(`Invalid config file: ${configPath}`));
+  } catch (error) {
+    return new ConfigError(
+      'Error parsing config',
+      new Error(`Error parsing config: ${configPath} - ${error.message}`)
+    );
+  }
+}
+
+export function normalizeConfig(configPath) {
+  const parsedConfigResult = parseConfig(configPath);
+  if (isError(parsedConfigResult)) {
+    return parsedConfigResult;
+  }
+
+  const normalized = parserFactory.normalizeToInternalFormat(parsedConfigResult, configPath);
+  if (!normalized) {
+    return new ConfigError('No servers found in config');
+  }
+
+  // Convert to flat map format expected by MCP server
+  const out = new Map();
+
+  // Handle normalized mcpServers format
+  if (normalized.mcpServers) {
+    for (const [name, cfg] of Object.entries(normalized.mcpServers)) {
+      const type = cfg.type ?? DEFAULT_TYPE;
+      out.set(name, { type, ...cfg });
+    }
+  }
+
+  // Handle normalized servers format (legacy)
+  if (normalized.servers) {
+    for (const [name, cfg] of Object.entries(normalized.servers)) {
+      const type = cfg.type ?? DEFAULT_TYPE;
+      out.set(name, { type, ...cfg });
+    }
+  }
+
+  if (out.size === 0) {
+    return new ConfigError('No servers found in config');
+  }
+
+  return Object.fromEntries(out);
+}

package/{mcp-server/lib → core/mcp-server}/server/external/single/client.js

@@ -1,5 +1,5 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { CompositeError } from '../../../common/error.js';
+import { CompositeError } from '#core/libraries/ErrorLibrary.js';
 
 const DEFAULT_VERSION = '1.0.0';
 const DEFAULT_NAME = 'mcp-client';

package/{mcp-server/lib → core/mcp-server}/server/external/single/request.js

@@ -4,7 +4,7 @@ import {
   ListToolsResultSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 
-import { CompositeError } from '../../../common/error.js';
+import { CompositeError } from '#core/libraries/ErrorLibrary.js';
 const METHOD_NOT_FOUND_CODE = '-32601';
 
 export class RequestError extends CompositeError {

package/{mcp-server/lib → core/mcp-server}/server/external/single/run.js

@@ -1,4 +1,4 @@
-import { CompositeError, getErrors, isError } from '../../../common/error.js';
+import { CompositeError, getErrors, isError } from '#core/libraries/ErrorLibrary.js';
 import { createClient } from './client.js';
 import * as requests from './request.js';
 import { makeTransport } from './transport.js';
@@ -10,6 +10,21 @@ export class RunError extends CompositeError {
   }
 }
 
+function createCallTool(client, args) {
+  return client.callTool.bind(client)(args);
+}
+
+function createReadResource(client, resourceUri) {
+  return client.readResource.bind(client)(resourceUri);
+}
+
+function createGetPrompt(client, promptName, args) {
+  return client.getPrompt.bind(client)({
+    name: promptName,
+    arguments: args,
+  });
+}
+
 export async function runExternalServer({ logger, name, config }) {
   logger.debug(`Starting external server run for server ${name} with config:`, config);
 
@@ -44,21 +59,15 @@ export async function runExternalServer({ logger, name, config }) {
   }
 
   const [{ tools }, { resources }, { prompts }] = results.map((result) => result.value);
+
   return {
     name,
     client,
     tools,
     resources,
     prompts,
-    callTool: (args) => client.callTool.bind(client)(args),
-    readResource: (resourceUri) => {
-      return client.readResource.bind(client)(resourceUri);
-    },
-    getPrompt: (promptName, args) => {
-      return client.getPrompt.bind(client)({
-        name: promptName,
-        arguments: args,
-      });
-    },
+    callTool: (args) => createCallTool(client, args),
+    readResource: (resourceUri) => createReadResource(client, resourceUri),
+    getPrompt: (promptName, args) => createGetPrompt(client, promptName, args),
   };
 }

package/{mcp-server/lib → core/mcp-server}/server/external/single/transport.js

@@ -2,7 +2,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
 
-import { CompositeError } from '../../../common/error.js';
+import { CompositeError } from '#core/libraries/ErrorLibrary.js';
 
 export class TransportError extends CompositeError {
   constructor(message, error) {

package/{mcp-server/lib → core/mcp-server}/server/internal/handlers/error.js

@@ -1,4 +1,4 @@
-import { CompositeError } from '../../../common/error.js';
+import { CompositeError } from '#core/libraries/ErrorLibrary.js';
 
 export class InternalServerError extends CompositeError {
   constructor(message, error) {

package/core/mcp-server/server/internal/handlers/prompts-get.js

@@ -0,0 +1,28 @@
+import { getBy } from '../../external/kv.js';
+import { InternalServerError } from './error.js';
+
+async function handlePromptsGet(req, logger, mcpServers, requestedMcpServer) {
+  const name = req.params.name;
+  const promptArgs = req?.params?.arguments || {};
+  logger.debug('Prompt get', name, promptArgs);
+
+  const getPrompt = getBy(mcpServers, requestedMcpServer, name, 'getPrompt', promptArgs);
+  if (!getPrompt) {
+    throw new InternalServerError(`Prompt not found: ${name}`);
+  }
+
+  const result = await getPrompt(name, promptArgs);
+  logger.debug('Prompt get result', result);
+
+  return result;
+}
+
+function createPromptsGetHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handlePromptsGet(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createPromptsGetHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createPromptsGetHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/handlers/prompts-list.js

@@ -0,0 +1,21 @@
+import { listAll } from '../../external/kv.js';
+
+async function handlePromptsList(req, logger, mcpServers, requestedMcpServer) {
+  const path = req.path;
+  logger.debug('Prompts list', path);
+
+  const res = await listAll(mcpServers, requestedMcpServer, 'prompts');
+  const result = Array.isArray(res) ? { prompts: res } : res;
+
+  return result;
+}
+
+function createPromptsListHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handlePromptsList(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createPromptsListHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createPromptsListHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/handlers/resources-list.js

@@ -0,0 +1,21 @@
+import { listAll } from '../../external/kv.js';
+
+async function handleResourcesList(req, logger, mcpServers, requestedMcpServer) {
+  const path = req.path;
+  logger.debug('Resources list', path);
+
+  const res = await listAll(mcpServers, requestedMcpServer, 'resources');
+  const result = Array.isArray(res) ? { resources: res } : res;
+
+  return result;
+}
+
+function createResourcesListHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handleResourcesList(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createResourcesListHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createResourcesListHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/handlers/resources-read.js

@@ -0,0 +1,28 @@
+import { getBy } from '../../external/kv.js';
+import { InternalServerError } from './error.js';
+
+async function handleResourcesRead(req, logger, mcpServers, requestedMcpServer) {
+  const path = req.path;
+  const uri = req.params.uri;
+  logger.debug('Resource read', path, uri);
+
+  const readResource = getBy(mcpServers, requestedMcpServer, uri, 'readResource');
+  if (!readResource) {
+    throw new InternalServerError(`Resource not found: ${uri}`);
+  }
+
+  const result = await readResource(uri);
+  logger.debug('Resource read result', result);
+
+  return result;
+}
+
+function createResourcesReadHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handleResourcesRead(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createResourcesReadHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createResourcesReadHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/handlers/tools-call.js

@@ -0,0 +1,44 @@
+import { getBy } from '../../external/kv.js';
+import { InternalServerError } from './error.js';
+
+const isAsyncIterable = (v) => v && typeof v[Symbol.asyncIterator] === 'function';
+
+async function* createLoggedStream(result, logger) {
+  for await (const chunk of result) {
+    logger.debug('Tool call chunk forwarded', chunk);
+    yield chunk;
+  }
+}
+
+async function handleToolsCall(req, logger, mcpServers, requestedMcpServer) {
+  const path = req.path;
+  const { name, arguments: args } = req.params;
+  logger.debug('Tool call', path, name, args);
+
+  const callTool = getBy(mcpServers, requestedMcpServer, name, 'callTool', args || {});
+  if (!callTool) {
+    throw new InternalServerError(`Tool not found: ${name}`);
+  }
+
+  const result = await callTool({
+    ...req.params,
+    name,
+  });
+  logger.debug('Tool call result', result);
+
+  if (isAsyncIterable(result)) {
+    return createLoggedStream(result, logger);
+  }
+
+  return result;
+}
+
+function createToolsCallHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handleToolsCall(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createToolsCallHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createToolsCallHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/handlers/tools-list.js

@@ -0,0 +1,23 @@
+import { listAll } from '../../external/kv.js';
+
+async function handleToolsList(req, logger, mcpServers, requestedMcpServer) {
+  const path = req.path;
+  logger.debug('Listing tools', path);
+
+  const res = await listAll(mcpServers, requestedMcpServer, 'tools');
+  logger.debug('Tools list result', JSON.stringify(res));
+
+  const result = Array.isArray(res) ? { tools: res } : res;
+
+  return result;
+}
+
+function createToolsListHandlerWrapper(req, logger, mcpServers, requestedMcpServer) {
+  return handleToolsList(req, logger, mcpServers, requestedMcpServer);
+}
+
+export function createToolsListHandler(logger, mcpServers, requestedMcpServer) {
+  return async (req) => {
+    return createToolsListHandlerWrapper(req, logger, mcpServers, requestedMcpServer);
+  };
+}

package/core/mcp-server/server/internal/run.js

@@ -0,0 +1,53 @@
+import cors from 'cors';
+import express from 'express';
+
+import { withSession } from './session.js';
+
+async function handleMcpRoute(
+  req,
+  res,
+  serverFactory,
+  withAuditRequestResponseHandler,
+  auditLogger
+) {
+  await withSession(serverFactory, withAuditRequestResponseHandler, req, res, auditLogger);
+}
+
+function handleNotFoundRoute(_req, res) {
+  res.status(404).json({ error: 'Not found' });
+}
+
+export function getInternalServer(serverFactory, auditLogger, withAuditRequestResponseHandler) {
+  const app = express();
+
+  // Parse JSON body for POST requests
+  app.use(express.json());
+  app.use(
+    '/mcp',
+    cors({
+      origin: ['*'],
+      methods: ['*'],
+      allowedHeaders: ['*'],
+      exposedHeaders: ['*'],
+    })
+  );
+
+  app.all('/mcp/*', (req, res) => {
+    return handleMcpRoute(req, res, serverFactory, withAuditRequestResponseHandler, auditLogger);
+  });
+
+  // Catch-all for other routes (404)
+  app.use(handleNotFoundRoute);
+
+  return app;
+}
+
+function handleServerListen(logger, port) {
+  logger.info(`MCP proxy HTTP server listening on http://localhost:${port}/mcp`);
+}
+
+export function runInternalServer(logger, port, app) {
+  app.listen(port, '0.0.0.0', () => {
+    handleServerListen(logger, port);
+  });
+}

package/{mcp-server/lib → core/mcp-server}/server/internal/server.js

@@ -57,6 +57,16 @@ export function createInternalServer(logger, mcpServers, requestedMcpServer) {
   return server;
 }
 
+function createInternalServerForRequested(logger, mcpServers, requestedMcpServer) {
+  return createInternalServer(logger, mcpServers, requestedMcpServer);
+}
+
+function createInternalServerFactoryWrapper(logger, mcpServers, requestedMcpServer) {
+  return createInternalServerForRequested(logger, mcpServers, requestedMcpServer);
+}
+
 export function createInternalServerFactory(logger, mcpServers) {
-  return (requestedMcpServer) => createInternalServer(logger, mcpServers, requestedMcpServer);
+  return (requestedMcpServer) => {
+    return createInternalServerFactoryWrapper(logger, mcpServers, requestedMcpServer);
+  };
 }

package/core/models/ConversationFilters.js

@@ -0,0 +1,31 @@
+/**
+ * Conversation filters model
+ */
+import { Defaults } from '../constants/Defaults.js';
+
+export class ConversationFilters {
+  constructor(data = {}) {
+    this.sessionId = data.sessionId || null;
+    this.method = data.method || null;
+    this.status = data.status || null;
+    this.jsonrpcId = data.jsonrpcId || null;
+    this.startTime = data.startTime !== undefined ? data.startTime : null;
+    this.endTime = data.endTime !== undefined ? data.endTime : null;
+    this.limit = data.limit !== undefined ? Number.parseInt(data.limit) : Defaults.DEFAULT_LIMIT;
+    this.offset =
+      data.offset !== undefined ? Number.parseInt(data.offset) : Defaults.DEFAULT_OFFSET;
+  }
+
+  toRepositoryFilters() {
+    return {
+      sessionId: this.sessionId,
+      method: this.method,
+      status: this.status,
+      jsonrpcId: this.jsonrpcId,
+      startTime: this.startTime ? BigInt(this.startTime) : null,
+      endTime: this.endTime ? BigInt(this.endTime) : null,
+      limit: this.limit,
+      offset: this.offset,
+    };
+  }
+}

package/core/models/ExportFormat.js

@@ -0,0 +1,8 @@
+/**
+ * Export format enum
+ */
+export const ExportFormat = {
+  JSON: 'json',
+  CSV: 'csv',
+  TXT: 'txt',
+};

package/core/models/RequestFilters.js

@@ -0,0 +1,43 @@
+/**
+ * Request filters model
+ * Used for filtering packet/request queries
+ */
+import { Defaults } from '../constants/Defaults.js';
+
+export class RequestFilters {
+  constructor(data = {}) {
+    this.sessionId = data.sessionId || null;
+    this.direction = data.direction || null;
+    this.method = data.method || null;
+    this.jsonrpcMethod = data.jsonrpcMethod || null;
+    this.statusCode = data.statusCode !== undefined ? data.statusCode : null;
+    this.jsonrpcId = data.jsonrpcId || null;
+    this.search = data.search || null;
+    this.serverName = data.serverName || null;
+    this.startTime = data.startTime !== undefined ? data.startTime : null;
+    this.endTime = data.endTime !== undefined ? data.endTime : null;
+    this.limit = data.limit !== undefined ? Number.parseInt(data.limit) : Defaults.DEFAULT_LIMIT;
+    this.offset =
+      data.offset !== undefined ? Number.parseInt(data.offset) : Defaults.DEFAULT_OFFSET;
+  }
+
+  /**
+   * Convert to repository filter format
+   */
+  toRepositoryFilters() {
+    return {
+      sessionId: this.sessionId,
+      direction: this.direction,
+      method: this.method,
+      jsonrpcMethod: this.jsonrpcMethod,
+      statusCode: this.statusCode,
+      jsonrpcId: this.jsonrpcId,
+      search: this.search,
+      serverName: this.serverName,
+      startTime: this.startTime ? BigInt(this.startTime) : null,
+      endTime: this.endTime ? BigInt(this.endTime) : null,
+      limit: this.limit,
+      offset: this.offset,
+    };
+  }
+}

package/core/models/SessionFilters.js

@@ -0,0 +1,23 @@
+/**
+ * Session filters model
+ */
+import { Defaults } from '../constants/Defaults.js';
+
+export class SessionFilters {
+  constructor(data = {}) {
+    this.startTime = data.startTime !== undefined ? data.startTime : null;
+    this.endTime = data.endTime !== undefined ? data.endTime : null;
+    this.limit = data.limit !== undefined ? Number.parseInt(data.limit) : Defaults.DEFAULT_LIMIT;
+    this.offset =
+      data.offset !== undefined ? Number.parseInt(data.offset) : Defaults.DEFAULT_OFFSET;
+  }
+
+  toRepositoryFilters() {
+    return {
+      startTime: this.startTime ? BigInt(this.startTime) : null,
+      endTime: this.endTime ? BigInt(this.endTime) : null,
+      limit: this.limit,
+      offset: this.offset,
+    };
+  }
+}

package/core/models/index.js

@@ -0,0 +1,8 @@
+/**
+ * Model layer exports
+ * All models used for service layer communication
+ */
+export { RequestFilters } from './RequestFilters.js';
+export { SessionFilters } from './SessionFilters.js';
+export { ConversationFilters } from './ConversationFilters.js';
+export { ExportFormat } from './ExportFormat.js';