@mcp-shark/mcp-shark 1.4.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,49 @@
+import express from 'express';
+import cors from 'cors';
+
+import { withSession } from './session.js';
+
+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', async (req, res) => {
+    await withSession(
+      serverFactory,
+      withAuditRequestResponseHandler,
+      req,
+      res,
+      auditLogger
+    );
+  });
+
+  // Catch-all for other routes (404)
+  app.use((_req, res) => {
+    res.status(404).json({ error: 'Not found' });
+  });
+
+  return app;
+}
+
+export function runInternalServer(logger, port, app) {
+  app.listen(port, '0.0.0.0', () => {
+    logger.info(
+      `MCP proxy HTTP server listening on http://localhost:${port}/mcp`
+    );
+  });
+}

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

@@ -0,0 +1,63 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { createToolsListHandler } from './handlers/tools-list.js';
+import { createToolsCallHandler } from './handlers/tools-call.js';
+import { createPromptsListHandler } from './handlers/prompts-list.js';
+import { createPromptsGetHandler } from './handlers/prompts-get.js';
+import { createResourcesListHandler } from './handlers/resources-list.js';
+import { createResourcesReadHandler } from './handlers/resources-read.js';
+import { SERVER_NAME } from './handlers/common.js';
+
+export function createInternalServer(logger, mcpServers) {
+  // create MCP server
+  const server = new Server(
+    { name: SERVER_NAME, version: '1.0.0' },
+    { capabilities: { tools: {}, prompts: {}, resources: {} } }
+  );
+
+  // Register handlers
+  server.setRequestHandler(
+    ListToolsRequestSchema,
+    createToolsListHandler(logger, mcpServers)
+  );
+
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    createToolsCallHandler(logger, mcpServers)
+  );
+
+  server.setRequestHandler(
+    ListPromptsRequestSchema,
+    createPromptsListHandler(logger, mcpServers)
+  );
+
+  server.setRequestHandler(
+    GetPromptRequestSchema,
+    createPromptsGetHandler(logger, mcpServers)
+  );
+
+  server.setRequestHandler(
+    ListResourcesRequestSchema,
+    createResourcesListHandler(logger, mcpServers)
+  );
+
+  server.setRequestHandler(
+    ReadResourceRequestSchema,
+    createResourcesReadHandler(logger, mcpServers)
+  );
+
+  return server;
+}
+
+export function createInternalServerFactory(logger, mcpServers) {
+  return () => createInternalServer(logger, mcpServers);
+}

package/mcp-server/lib/server/internal/session.js

@@ -0,0 +1,39 @@
+import { randomUUID } from 'node:crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+
+import { getSessionFromRequest } from './handlers/common.js';
+
+const sessions = new Map();
+
+function storeTransportInSession(sessionId, transport) {
+  sessions.set(sessionId, transport);
+}
+
+function getTransportFromSession(sessionId) {
+  return sessions.get(sessionId);
+}
+
+export async function withSession(
+  serverFactory,
+  requestHandler,
+  req,
+  res,
+  auditLogger
+) {
+  const sessionId = getSessionFromRequest(req);
+  if (!sessionId) {
+    const newSessionId = randomUUID();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => newSessionId,
+      enableJsonResponse: true,
+    });
+    const server = serverFactory();
+    await server.connect(transport);
+    storeTransportInSession(newSessionId, transport);
+    // Session creation will be logged as part of the request packet in audit.js
+    return requestHandler(transport, req, res, auditLogger);
+  }
+
+  const transport = getTransportFromSession(sessionId);
+  return requestHandler(transport, req, res, auditLogger);
+}

package/mcp-server/mcp-shark.js

@@ -0,0 +1,72 @@
+import { consola } from 'consola';
+
+import { runAllExternalServers } from './lib/server/external/all.js';
+import { isError } from './lib/common/error.js';
+
+import { createInternalServerFactory } from './lib/server/internal/server.js';
+import {
+  getInternalServer,
+  runInternalServer,
+} from './lib/server/internal/run.js';
+import { initDb } from 'mcp-shark-common/db/init.js';
+import { getLogger } from 'mcp-shark-common/db/logger.js';
+import {
+  getDatabaseFile,
+  getMcpConfigPath,
+  prepareAppDataSpaces,
+} from 'mcp-shark-common/configs/index.js';
+import { withAuditRequestResponseHandler } from './lib/auditor/audit.js';
+
+function initAuditLogger(logger) {
+  logger.info('Initializing audit logger at', getDatabaseFile());
+  return getLogger(initDb(getDatabaseFile()));
+}
+
+async function main() {
+  consola.level = 'info';
+
+  prepareAppDataSpaces();
+
+  const configPath = getMcpConfigPath();
+  console.log('[MCP-Shark] Starting MCP server...');
+  console.log(`[MCP-Shark] Config path: ${configPath}`);
+  console.log(`[MCP-Shark] Database path: ${getDatabaseFile()}`);
+  console.log(`[MCP-Shark] Working directory: ${process.cwd()}`);
+  console.log(`[MCP-Shark] PATH: ${process.env.PATH}`);
+
+  const auditLogger = initAuditLogger(consola);
+  const result = await runAllExternalServers(consola, configPath);
+  if (isError(result)) {
+    console.error(JSON.stringify(result));
+    process.exit(1);
+  }
+
+  const internalServerFactory = createInternalServerFactory(consola, result);
+  const app = getInternalServer(
+    internalServerFactory,
+    auditLogger,
+    withAuditRequestResponseHandler
+  );
+  await runInternalServer(consola, 9851, app);
+}
+
+main()
+  .then(() => {
+    const successMsg = 'MCP server started successfully';
+    console.log(`[MCP-Shark] ${successMsg}`);
+    consola.info(successMsg);
+  })
+  .catch(error => {
+    const errorMsg = 'Error starting MCP server';
+    console.error(`[MCP-Shark] ${errorMsg}:`, error);
+    console.error(`[MCP-Shark] Error message: ${error.message}`);
+    if (error.stack) {
+      console.error(`[MCP-Shark] Error stack:`, error.stack);
+    }
+    consola.error(errorMsg, error);
+    consola.error(`Error message: ${error.message}`);
+    if (error.stack) {
+      consola.error(`Error stack: ${error.stack}`);
+    }
+    process.exit(1);
+  });