@mcp-shark/mcp-shark 1.4.0

package/mcp-server/lib/auditor/audit.js

@@ -0,0 +1,228 @@
+import { Readable } from 'node:stream';
+import { parse as parseJsonRpc } from 'jsonrpc-lite';
+import { getSessionFromRequest } from '../server/internal/handlers/common.js';
+
+/* ---------- helpers ---------- */
+
+function toBuffer(body) {
+  if (body === undefined || body === null) {
+    return Buffer.alloc(0);
+  }
+
+  if (Buffer.isBuffer(body)) {
+    return body;
+  }
+
+  if (
+    typeof body === 'object' &&
+    body.type === 'Buffer' &&
+    Array.isArray(body.data)
+  ) {
+    return Buffer.from(body.data);
+  }
+
+  if (typeof body === 'string') {
+    return Buffer.from(body, 'utf8');
+  }
+
+  if (typeof body === 'object') {
+    return Buffer.from(JSON.stringify(body));
+  }
+
+  return Buffer.alloc(0);
+}
+
+async function readBody(req) {
+  if (req.body) {
+    return toBuffer(req.body);
+  }
+
+  const chunks = [];
+
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+
+  return Buffer.concat(chunks);
+}
+
+function captureResponse(res) {
+  const chunks = [];
+
+  const wrapped = new Proxy(res, {
+    get(target, prop, receiver) {
+      if (prop === 'write') {
+        return function (chunk, ...args) {
+          if (chunk) {
+            const buf = toBuffer(chunk);
+            chunks.push(buf);
+          }
+          return target.write(chunk, ...args);
+        };
+      }
+
+      if (prop === 'end') {
+        return function (chunk, ...args) {
+          if (chunk) {
+            const buf = toBuffer(chunk);
+            chunks.push(buf);
+          }
+          return target.end(chunk, ...args);
+        };
+      }
+
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+
+  return {
+    res: wrapped,
+    getBody: () => {
+      return Buffer.concat(chunks);
+    },
+  };
+}
+
+function tryParseJsonRpc(buf) {
+  if (!buf || buf.length === 0) {
+    return null;
+  }
+
+  const text = buf.toString('utf8');
+
+  try {
+    const parsed = parseJsonRpc(text);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function rebuildReq(req, buf) {
+  const r = new Readable({
+    read() {
+      this.push(buf);
+      this.push(null);
+    },
+  });
+
+  r.headers = req.headers;
+  r.method = req.method;
+  r.url = req.url;
+
+  return r;
+}
+
+function waitForResponseFinish(res) {
+  return new Promise(resolve => {
+    let done = false;
+
+    function finishOnce() {
+      if (!done) {
+        done = true;
+        resolve();
+      }
+    }
+
+    res.on('finish', finishOnce);
+    res.on('close', finishOnce);
+  });
+}
+
+/* ---------- main handler ---------- */
+
+export async function withAuditRequestResponseHandler(
+  transport,
+  req,
+  res,
+  auditLogger
+) {
+  const reqBuf = await readBody(req);
+  const reqJsonRpc = tryParseJsonRpc(reqBuf);
+
+  // Extract session ID from request
+  // If no session ID exists, it's an initiation request
+  const sessionId = getSessionFromRequest(req);
+
+  // Extract request body as string
+  const reqBodyStr = reqBuf.toString('utf8');
+  const reqBodyJson = (() => {
+    try {
+      return JSON.parse(reqBodyStr);
+    } catch {
+      return null;
+    }
+  })();
+
+  // Log request packet to database
+  const requestResult = auditLogger.logRequestPacket({
+    method: req.method,
+    url: req.url,
+    headers: req.headers,
+    body: reqBodyJson || reqBodyStr,
+    userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
+    remoteAddress: req.socket?.remoteAddress || null,
+    sessionId: sessionId || null,
+  });
+
+  const { res: wrappedRes, getBody } = captureResponse(res);
+
+  const replayReq = req.body ? req : rebuildReq(req, reqBuf);
+
+  const parsedForTransport = reqJsonRpc
+    ? (() => {
+        try {
+          return JSON.parse(reqBuf.toString('utf8'));
+        } catch {
+          return undefined;
+        }
+      })()
+    : undefined;
+
+  // hand over to transport
+  if (!transport || typeof transport.handleRequest !== 'function') {
+    res.status(500).json({ error: 'Transport not available' });
+    return;
+  }
+  await transport.handleRequest(replayReq, wrappedRes, parsedForTransport);
+
+  // wait until response fully finished (important for SSE / streaming)
+  await waitForResponseFinish(wrappedRes);
+
+  const resBuf = getBody();
+
+  const resHeaders =
+    wrappedRes.getHeaders && typeof wrappedRes.getHeaders === 'function'
+      ? wrappedRes.getHeaders()
+      : {};
+
+  // Extract response body as string
+  const resBodyStr = resBuf.toString('utf8');
+  const resBodyJson = (() => {
+    try {
+      return JSON.parse(resBodyStr);
+    } catch {
+      return null;
+    }
+  })();
+
+  // Extract JSON-RPC ID from request for correlation
+  const jsonrpcId =
+    reqJsonRpc?.payload?.id !== undefined
+      ? String(reqJsonRpc.payload.id)
+      : null;
+
+  // Log response packet to database
+  // Use the same session ID from the request
+  auditLogger.logResponsePacket({
+    statusCode: wrappedRes.statusCode || 200,
+    headers: resHeaders,
+    body: resBodyJson || resBodyStr,
+    requestFrameNumber: requestResult?.frameNumber || null,
+    requestTimestampNs: requestResult?.timestampNs || null,
+    jsonrpcId,
+    sessionId: sessionId || null,
+    userAgent: req.headers['user-agent'] || req.headers['User-Agent'] || null,
+    remoteAddress: req.socket?.remoteAddress || null,
+  });
+}

package/mcp-server/lib/common/error.js

@@ -0,0 +1,15 @@
+export class CompositeError extends Error {
+  constructor(name, message, error) {
+    super(name, message);
+    this.name = name;
+    this.error = error;
+  }
+}
+
+export function isError(error) {
+  return error instanceof CompositeError || error instanceof Error;
+}
+
+export function getErrors(results) {
+  return results.filter(result => isError(result));
+}

package/mcp-server/lib/server/external/all.js

@@ -0,0 +1,32 @@
+import { normalizeConfig } from './config.js';
+import { runExternalServer } from './single/run.js';
+import { CompositeError, getErrors } from '../../common/error.js';
+import { buildKv } from './kv.js';
+
+export class RunAllExternalServersError extends CompositeError {
+  constructor(message, error, errors = []) {
+    super('RunAllExternalServersError', message, error);
+    this.errors = errors;
+  }
+}
+
+export async function runAllExternalServers(logger, parsedConfig) {
+  const configs = normalizeConfig(parsedConfig);
+  const results = await Promise.all(
+    Object.entries(configs).map(([name, config]) =>
+      runExternalServer({ logger, name, config })
+    )
+  );
+
+  const flattenedResults = results.flat();
+  const errors = getErrors(flattenedResults);
+  if (errors.length > 0) {
+    return new RunAllExternalServersError(
+      'Errors occurred while running all external servers',
+      null,
+      errors
+    );
+  }
+
+  return buildKv(flattenedResults);
+}

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

@@ -0,0 +1,59 @@
+import { readFileSync } from 'node:fs';
+import { CompositeError, isError } from '../../common/error.js';
+
+const DEFAULT_TYPE = 'stdio';
+export class ConfigError extends CompositeError {
+  constructor(message, error) {
+    super('ConfigError', message, error);
+  }
+}
+
+function parseConfig(configPath) {
+  try {
+    const conf = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (conf && typeof conf === 'object') {
+      return conf;
+    }
+    return new ConfigError(
+      'Invalid config file',
+      new Error(
+        `Invalid config file: ${configPath} - ${JSON.stringify(conf, null, 2)}`
+      )
+    );
+  } 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 out = new Map();
+  const { servers, mcpServers } = parsedConfigResult;
+  // Servers are the old format
+  if (servers) {
+    Object.entries(servers).forEach(([name, cfg]) => {
+      const type = cfg.type ?? DEFAULT_TYPE;
+      out.set(name, { type, ...cfg });
+    });
+  }
+  // MCP Servers are the new format
+  if (mcpServers) {
+    Object.entries(mcpServers).forEach(([name, cfg]) => {
+      // Cursor/Claude usually omit type; assume stdio if command is given
+      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/server/external/kv.js

@@ -0,0 +1,102 @@
+const kv = new Map();
+
+function buildName(name, typeName) {
+  return `${name}.${typeName}`;
+}
+
+export function extractName(name) {
+  const [serverName, typeName] = name.split('.');
+  return { serverName, typeName };
+}
+
+export function buildKv(downstreamServers) {
+  for (const downstreamServer of downstreamServers) {
+    const {
+      name,
+      tools,
+      resources,
+      prompts,
+      callTool,
+      getPrompt,
+      readResource,
+    } = downstreamServer;
+
+    if (!kv.has(name)) {
+      const toolsMap = new Map();
+      const resourcesMap = new Map();
+      const promptsMap = new Map();
+
+      for (const tool of tools) {
+        toolsMap.set(tool.name, callTool);
+      }
+
+      for (const resource of resources) {
+        resourcesMap.set(resource.name, readResource);
+      }
+
+      for (const prompt of prompts) {
+        promptsMap.set(prompt.name, getPrompt);
+      }
+
+      kv.set(name, {
+        toolsMap,
+        resourcesMap,
+        promptsMap,
+        tools: tools.map(tool => {
+          return { ...tool, name: buildName(name, tool.name) };
+        }),
+        resources: resources.map(resource => {
+          return {
+            ...resource,
+            name: buildName(name, resource.name),
+          };
+        }),
+        prompts: prompts.map(prompt => {
+          return { ...prompt, name: buildName(name, prompt.name) };
+        }),
+      });
+    }
+  }
+
+  return kv;
+}
+
+export function getBy(database, calledName, action) {
+  const { serverName, typeName } = extractName(calledName);
+  if (!serverName || !typeName) {
+    return null;
+  }
+  const entry = database.get(serverName);
+  if (!entry) {
+    return null;
+  }
+
+  // Type-based lookup
+  if (action === 'getTools') {
+    return entry.toolsMap.get(typeName);
+  }
+  if (action === 'getResources') {
+    return entry.resourcesMap.get(typeName);
+  }
+  if (action === 'getPrompts') {
+    return entry.promptsMap.get(typeName);
+  }
+
+  // Action-based lookup
+  if (action === 'callTool') {
+    return entry.toolsMap.get(typeName);
+  }
+  if (action === 'readResource') {
+    return entry.resourcesMap.get(typeName);
+  }
+  if (action === 'getPrompt') {
+    return entry.promptsMap.get(typeName);
+  }
+  return null;
+}
+
+export function listAll(database, type) {
+  return Array.from(database.values())
+    .map(entry => entry[type])
+    .flat();
+}

package/mcp-server/lib/server/external/single/client.js

@@ -0,0 +1,35 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { CompositeError } from '../../../common/error.js';
+
+const DEFAULT_VERSION = '1.0.0';
+const DEFAULT_NAME = 'mcp-client';
+const DEFAULT_CAPABILITIES = {};
+export class ClientError extends CompositeError {
+  constructor(message, error) {
+    super('ClientError', message, error);
+  }
+}
+
+export async function createClient({
+  name = DEFAULT_NAME,
+  version = DEFAULT_VERSION,
+  capabilities = DEFAULT_CAPABILITIES,
+  transport,
+}) {
+  const client = new Client({ name, version }, { capabilities });
+
+  try {
+    await client.connect(transport);
+    return client;
+  } catch (error) {
+    return new ClientError('Failed to connect to server', error);
+  }
+}
+
+export async function closeClient(client) {
+  try {
+    await client.close();
+  } catch (error) {
+    return new ClientError('Failed to close client', error);
+  }
+}

package/mcp-server/lib/server/external/single/request.js

@@ -0,0 +1,49 @@
+import {
+  ListToolsResultSchema,
+  ListResourcesResultSchema,
+  ListPromptsResultSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { CompositeError } from '../../../common/error.js';
+const METHOD_NOT_FOUND_CODE = '-32601';
+
+export class RequestError extends CompositeError {
+  constructor(message, error) {
+    super('RequestError', message, error);
+  }
+}
+
+function isMethodNotFound(error) {
+  return error?.code?.toString() === METHOD_NOT_FOUND_CODE;
+}
+
+async function getListOf(client, typeOfList, schema) {
+  const fetchedList = {
+    [typeOfList]: [],
+  };
+  try {
+    const result = await client.request(
+      { method: `${typeOfList}/list` },
+      schema
+    );
+    fetchedList[typeOfList] = result[typeOfList];
+    return fetchedList;
+  } catch (error) {
+    if (isMethodNotFound(error)) {
+      return fetchedList;
+    }
+    return new RequestError(`Failed to list ${typeOfList}`, error);
+  }
+}
+
+export function listTools(client) {
+  return getListOf(client, 'tools', ListToolsResultSchema);
+}
+
+export function listResources(client) {
+  return getListOf(client, 'resources', ListResourcesResultSchema);
+}
+
+export function listPrompts(client) {
+  return getListOf(client, 'prompts', ListPromptsResultSchema);
+}

package/mcp-server/lib/server/external/single/run.js

@@ -0,0 +1,75 @@
+import { makeTransport } from './transport.js';
+import { createClient } from './client.js';
+import * as requests from './request.js';
+import { isError, CompositeError, getErrors } from '../../../common/error.js';
+
+export class RunError extends CompositeError {
+  constructor(message, error, errors = []) {
+    super('RunError', message, error);
+    this.errors = errors;
+  }
+}
+
+export async function runExternalServer({ logger, name, config }) {
+  logger.debug(
+    `Starting external server run for server ${name} with config:`,
+    config
+  );
+
+  // Create transport
+  const transport = makeTransport(config);
+  if (isError(transport)) {
+    return new RunError(
+      `Error creating transport for external server ${name}`,
+      transport.error
+    );
+  }
+
+  // Create client
+  const client = await createClient({ transport });
+  if (isError(client)) {
+    return new RunError(
+      `Error creating client for external server ${name}`,
+      client.error
+    );
+  }
+
+  // Run requests
+  const allResults = [
+    requests.listTools(client),
+    requests.listResources(client),
+    requests.listPrompts(client),
+  ];
+  const results = await Promise.allSettled(allResults);
+
+  // Check for errors
+  const errors = getErrors(results);
+  if (errors.length > 0) {
+    return new RunError(
+      `Errors occurred while running requests for external server ${name}`,
+      null,
+      errors
+    );
+  }
+
+  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,
+      });
+    },
+  };
+}

package/mcp-server/lib/server/external/single/transport.js

@@ -0,0 +1,57 @@
+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';
+
+export class TransportError extends CompositeError {
+  constructor(message, error) {
+    super('TransportError', message, error);
+  }
+}
+
+export function makeTransport({
+  type,
+  url,
+  headers: configHeaders = {},
+  command,
+  args = [],
+  env: configEnv = {},
+}) {
+  // Start with enhanced PATH
+  const env = {
+    ...process.env,
+    ...configEnv,
+  };
+
+  const requestInit = { headers: { ...configHeaders } };
+
+  switch (type) {
+    case 'stdio':
+      return new StdioClientTransport({ command, args, env });
+    case 'http':
+    case 'sse':
+    case 'streamable-http':
+      return new StreamableHTTPClientTransport(new URL(url), {
+        requestInit,
+      });
+    case 'ws':
+    case 'websocket':
+      return new WebSocketClientTransport(new URL(url));
+    default:
+      if (command) {
+        // fallback: assume stdio if only command is provided
+        return new StdioClientTransport({
+          command,
+          args,
+          env,
+        });
+      }
+      return new TransportError(
+        'Unsupported server config',
+        new Error(
+          `Unsupported server config: ${JSON.stringify({ type, url, configHeaders, command, args })}`
+        )
+      );
+  }
+}

package/mcp-server/lib/server/internal/handlers/common.js

@@ -0,0 +1,20 @@
+export const SERVER_NAME = 'mcp-internal-server';
+export const TRANSPORT_TYPE = 'http';
+
+export function getSessionFromRequest(req) {
+  if (!req) {
+    return null;
+  }
+  if (req.sessionId) {
+    return req.sessionId;
+  }
+  if (req.get && typeof req.get === 'function') {
+    if (req.get('Mcp-Session-Id')) {
+      return req.get('Mcp-Session-Id');
+    }
+    if (req.get('X-MCP-Session-Id')) {
+      return req.get('X-MCP-Session-Id');
+    }
+  }
+  return null;
+}

package/mcp-server/lib/server/internal/handlers/error.js

@@ -0,0 +1,7 @@
+import { CompositeError } from '../../../common/error.js';
+
+export class InternalServerError extends CompositeError {
+  constructor(message, error) {
+    super('InternalServerError', message, error);
+  }
+}

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

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