mcp-proxy 2.13.0 → 2.13.1

package/src/bin/mcp-proxy.ts

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { EventSource } from "eventsource";
 import { setTimeout } from "node:timers";
-import { StdioClientTransport } from "../StdioClientTransport.js";
 import util from "node:util";
-import { startSSEServer } from "../startSSEServer.js";
-import { startHTTPStreamServer } from "../startHTTPStreamServer.js";
-import { proxyServer } from "../proxyServer.js";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
 import { InMemoryEventStore } from "../InMemoryEventStore.js";
+import { proxyServer } from "../proxyServer.js";
+import { startHTTPStreamServer } from "../startHTTPStreamServer.js";
+import { startSSEServer } from "../startSSEServer.js";
+import { StdioClientTransport } from "../StdioClientTransport.js";
 
 util.inspect.defaultOptions.depth = 8;
 
@@ -24,36 +25,36 @@ const argv = await yargs(hideBin(process.argv))
   .scriptName("mcp-proxy")
   .command("$0 <command> [args...]", "Run a command with MCP arguments")
   .positional("command", {
-    type: "string",
-    describe: "The command to run",
     demandOption: true,
+    describe: "The command to run",
+    type: "string",
   })
   .positional("args", {
-    type: "string",
     array: true,
     describe: "The arguments to pass to the command",
+    type: "string",
   })
   .env("MCP_PROXY")
   .options({
     debug: {
-      type: "boolean",
-      describe: "Enable debug logging",
       default: false,
+      describe: "Enable debug logging",
+      type: "boolean",
     },
     endpoint: {
-      type: "string",
       describe: "The endpoint to listen on",
+      type: "string",
     },
     port: {
-      type: "number",
-      describe: "The port to listen on",
       default: 8080,
+      describe: "The port to listen on",
+      type: "number",
     },
     server: {
-      type: "string",
-      describe: "The server type to use (sse or stream)",
       choices: ["sse", "stream"],
       default: "sse",
+      describe: "The server type to use (sse or stream)",
+      type: "string",
     },
   })
   .help()
@@ -61,15 +62,15 @@ const argv = await yargs(hideBin(process.argv))
 
 const connect = async (client: Client) => {
   const transport = new StdioClientTransport({
-    command: argv.command,
     args: argv.args,
+    command: argv.command,
     env: process.env as Record<string, string>,
-    stderr: "pipe",
     onEvent: (event) => {
       if (argv.debug) {
         console.debug("transport event", event);
       }
     },
+    stderr: "pipe",
   });
 
   await client.connect(transport);
@@ -83,7 +84,7 @@ const proxy = async () => {
     },
     {
       capabilities: {},
-    }
+    },
   );
 
   await connect(client);
@@ -93,7 +94,9 @@ const proxy = async () => {
     version: string;
   };
 
-  const serverCapabilities = client.getServerCapabilities() as {};
+  const serverCapabilities = client.getServerCapabilities() as {
+    capabilities: Record<string, unknown>;
+  };
 
   console.info("starting the %s server on port %d", argv.server, argv.port);
 
@@ -103,8 +106,8 @@ const proxy = async () => {
     });
 
     proxyServer({
-      server,
       client,
+      server,
       serverCapabilities,
     });
 
@@ -114,15 +117,15 @@ const proxy = async () => {
   if (argv.server === "sse") {
     await startSSEServer({
       createServer,
-      port: argv.port,
       endpoint: argv.endpoint || ("/sse" as `/${string}`),
+      port: argv.port,
     });
   } else {
     await startHTTPStreamServer({
       createServer,
-      port: argv.port,
       endpoint: argv.endpoint || ("/stream" as `/${string}`),
       eventStore: new InMemoryEventStore(),
+      port: argv.port,
     });
   }
 };

package/src/index.ts

@@ -2,4 +2,4 @@ export { InMemoryEventStore } from "./InMemoryEventStore.js";
 export { proxyServer } from "./proxyServer.js";
 export { startHTTPStreamServer } from "./startHTTPStreamServer.js";
 export { startSSEServer } from "./startSSEServer.js";
-export { tapTransport } from "./tapTransport.js";
+export { tapTransport } from "./tapTransport.js";

package/src/proxyServer.ts

@@ -1,3 +1,4 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
@@ -9,20 +10,19 @@ import {
   ListToolsRequestSchema,
   LoggingMessageNotificationSchema,
   ReadResourceRequestSchema,
-  SubscribeRequestSchema,
-  UnsubscribeRequestSchema,
   ResourceUpdatedNotificationSchema,
   ServerCapabilities,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 
 export const proxyServer = async ({
-  server,
   client,
+  server,
   serverCapabilities,
 }: {
-  server: Server;
   client: Client;
+  server: Server;
   serverCapabilities: ServerCapabilities;
 }) => {
   if (serverCapabilities?.logging) {
@@ -62,10 +62,10 @@ export const proxyServer = async ({
 
     if (serverCapabilities?.resources.subscribe) {
       server.setNotificationHandler(
-          ResourceUpdatedNotificationSchema,
-          async (args) => {
-            return client.notification(args);
-          },
+        ResourceUpdatedNotificationSchema,
+        async (args) => {
+          return client.notification(args);
+        },
       );
 
       server.setRequestHandler(SubscribeRequestSchema, async (args) => {

package/src/simple-stdio-server.ts

@@ -1,8 +1,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-  ListResourceTemplatesRequestSchema,
   ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
   ReadResourceRequestSchema,
   SubscribeRequestSchema,
   UnsubscribeRequestSchema,
@@ -24,8 +24,8 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return {
     resources: [
       {
-        uri: "file:///example.txt",
         name: "Example Resource",
+        uri: "file:///example.txt",
       },
     ],
   };
@@ -36,9 +36,9 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     return {
       contents: [
         {
-          uri: "file:///example.txt",
           mimeType: "text/plain",
           text: "This is the content of the example resource.",
+          uri: "file:///example.txt",
         },
       ],
     };
@@ -51,9 +51,9 @@ server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
   return {
     resourceTemplates: [
       {
-        uriTemplate: `file://{filename}`,
-        name: "Example resource template",
         description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
       },
     ],
   };

package/src/startHTTPStreamServer.test.ts

@@ -1,13 +1,14 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { it, expect, vi } from "vitest";
-import { startHTTPStreamServer } from "./startHTTPStreamServer.js";
-import { getRandomPort } from "get-port-please";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { EventSource } from "eventsource";
+import { getRandomPort } from "get-port-please";
 import { setTimeout as delay } from "node:timers/promises";
+import { expect, it, vi } from "vitest";
+
 import { proxyServer } from "./proxyServer.js";
+import { startHTTPStreamServer } from "./startHTTPStreamServer.js";
 
 if (!("EventSource" in global)) {
   // @ts-expect-error - figure out how to use --experimental-eventsource with vitest
@@ -16,8 +17,8 @@ if (!("EventSource" in global)) {
 
 it("proxies messages between HTTP stream and stdio servers", async () => {
   const stdioTransport = new StdioClientTransport({
-    command: "tsx",
     args: ["src/simple-stdio-server.ts"],
+    command: "tsx",
   });
 
   const stdioClient = new Client(
@@ -27,7 +28,7 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
     },
     {
       capabilities: {},
-    }
+    },
   );
 
   await stdioClient.connect(stdioTransport);
@@ -37,7 +38,9 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
     version: string;
   };
 
-  const serverCapabilities = stdioClient.getServerCapabilities() as {};
+  const serverCapabilities = stdioClient.getServerCapabilities() as {
+    capabilities: Record<string, unknown>;
+  };
 
   const port = await getRandomPort();
 
@@ -51,17 +54,17 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
       });
 
       await proxyServer({
-        server: mcpServer,
         client: stdioClient,
+        server: mcpServer,
         serverCapabilities,
       });
 
       return mcpServer;
     },
-    port,
     endpoint: "/stream",
-    onConnect,
     onClose,
+    onConnect,
+    port,
   });
 
   const streamClient = new Client(
@@ -71,11 +74,11 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
     },
     {
       capabilities: {},
-    }
+    },
   );
 
   const transport = new StreamableHTTPClientTransport(
-    new URL(`http://localhost:${port}/stream`)
+    new URL(`http://localhost:${port}/stream`),
   );
 
   await streamClient.connect(transport);
@@ -84,20 +87,20 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
   expect(result).toEqual({
     resources: [
       {
-        uri: "file:///example.txt",
         name: "Example Resource",
+        uri: "file:///example.txt",
       },
     ],
   });
 
   expect(
-    await streamClient.readResource({ uri: result.resources[0].uri }, {})
+    await streamClient.readResource({ uri: result.resources[0].uri }, {}),
   ).toEqual({
     contents: [
       {
-        uri: "file:///example.txt",
         mimeType: "text/plain",
         text: "This is the content of the example resource.",
+        uri: "file:///example.txt",
       },
     ],
   });
@@ -106,9 +109,9 @@ it("proxies messages between HTTP stream and stdio servers", async () => {
   expect(await streamClient.listResourceTemplates()).toEqual({
     resourceTemplates: [
       {
-        uriTemplate: `file://{filename}`,
-        name: "Example resource template",
         description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
       },
     ],
   });

package/src/startHTTPStreamServer.ts

@@ -1,11 +1,12 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   EventStore,
   StreamableHTTPServerTransport,
 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { randomUUID } from "node:crypto";
-import http from "http";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import http from "http";
+import { randomUUID } from "node:crypto";
+
 import { InMemoryEventStore } from "./InMemoryEventStore.js";
 
 export type SSEServer = {
@@ -13,35 +14,35 @@ export type SSEServer = {
 };
 
 type ServerLike = {
-  connect: Server["connect"];
   close: Server["close"];
+  connect: Server["connect"];
 };
 
 export const startHTTPStreamServer = async <T extends ServerLike>({
-  port,
   createServer,
   endpoint,
   eventStore,
-  onConnect,
   onClose,
+  onConnect,
   onUnhandledRequest,
+  port,
 }: {
-  port: number;
-  endpoint: string;
   createServer: (request: http.IncomingMessage) => Promise<T>;
+  endpoint: string;
   eventStore?: EventStore;
-  onConnect?: (server: T) => void;
   onClose?: (server: T) => void;
+  onConnect?: (server: T) => void;
   onUnhandledRequest?: (
     req: http.IncomingMessage,
-    res: http.ServerResponse
+    res: http.ServerResponse,
   ) => Promise<void>;
+  port: number;
 }): Promise<SSEServer> => {
   const activeTransports: Record<
     string,
     {
-      transport: StreamableHTTPServerTransport;
       server: T;
+      transport: StreamableHTTPServerTransport;
     }
   > = {};
 
@@ -92,15 +93,15 @@ export const startHTTPStreamServer = async <T extends ServerLike>({
         } else if (!sessionId && isInitializeRequest(body)) {
           // Create a new transport for the session
           transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: randomUUID,
             eventStore: eventStore || new InMemoryEventStore(),
             onsessioninitialized: (_sessionId) => {
               // add only when the id Sesison id is generated
               activeTransports[_sessionId] = {
-                transport,
                 server,
+                transport,
               };
             },
+            sessionIdGenerator: randomUUID,
           });
 
           // Handle the server close event
@@ -139,13 +140,13 @@ export const startHTTPStreamServer = async <T extends ServerLike>({
           res.setHeader("Content-Type", "application/json");
           res.writeHead(400).end(
             JSON.stringify({
-              jsonrpc: "2.0",
               error: {
                 code: -32000,
                 message: "Bad Request: No valid session ID provided",
               },
               id: null,
-            })
+              jsonrpc: "2.0",
+            }),
           );
 
           return;
@@ -158,10 +159,10 @@ export const startHTTPStreamServer = async <T extends ServerLike>({
         res.setHeader("Content-Type", "application/json");
         res.writeHead(500).end(
           JSON.stringify({
-            jsonrpc: "2.0",
             error: { code: -32603, message: "Internal Server Error" },
             id: null,
-          })
+            jsonrpc: "2.0",
+          }),
         );
       }
       return;
@@ -174,8 +175,8 @@ export const startHTTPStreamServer = async <T extends ServerLike>({
       const sessionId = req.headers["mcp-session-id"] as string | undefined;
       const activeTransport:
         | {
-            transport: StreamableHTTPServerTransport;
             server: T;
+            transport: StreamableHTTPServerTransport;
           }
         | undefined = sessionId ? activeTransports[sessionId] : undefined;
 
@@ -213,7 +214,7 @@ export const startHTTPStreamServer = async <T extends ServerLike>({
 
       console.log("received delete request for session", sessionId);
 
-      const { transport, server } = activeTransports[sessionId];
+      const { server, transport } = activeTransports[sessionId];
       if (!transport) {
         res.writeHead(400).end("No active transport");
         return;

package/src/startSSEServer.test.ts

@@ -1,13 +1,14 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { it, expect, vi } from "vitest";
-import { startSSEServer } from "./startSSEServer.js";
-import { getRandomPort } from "get-port-please";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { EventSource } from "eventsource";
+import { getRandomPort } from "get-port-please";
 import { setTimeout as delay } from "node:timers/promises";
+import { expect, it, vi } from "vitest";
+
 import { proxyServer } from "./proxyServer.js";
+import { startSSEServer } from "./startSSEServer.js";
 
 if (!("EventSource" in global)) {
   // @ts-expect-error - figure out how to use --experimental-eventsource with vitest
@@ -16,8 +17,8 @@ if (!("EventSource" in global)) {
 
 it("proxies messages between SSE and stdio servers", async () => {
   const stdioTransport = new StdioClientTransport({
-    command: "tsx",
     args: ["src/simple-stdio-server.ts"],
+    command: "tsx",
   });
 
   const stdioClient = new Client(
@@ -37,7 +38,9 @@ it("proxies messages between SSE and stdio servers", async () => {
     version: string;
   };
 
-  const serverCapabilities = stdioClient.getServerCapabilities() as {};
+  const serverCapabilities = stdioClient.getServerCapabilities() as {
+    capabilities: Record<string, unknown>;
+  };
 
   const port = await getRandomPort();
 
@@ -51,17 +54,17 @@ it("proxies messages between SSE and stdio servers", async () => {
       });
 
       await proxyServer({
-        server: mcpServer,
         client: stdioClient,
+        server: mcpServer,
         serverCapabilities,
       });
 
       return mcpServer;
     },
-    port,
     endpoint: "/sse",
-    onConnect,
     onClose,
+    onConnect,
+    port,
   });
 
   const sseClient = new Client(
@@ -84,18 +87,20 @@ it("proxies messages between SSE and stdio servers", async () => {
   expect(result).toEqual({
     resources: [
       {
-        uri: "file:///example.txt",
         name: "Example Resource",
+        uri: "file:///example.txt",
       },
     ],
   });
 
-  expect(await sseClient.readResource({uri: (result.resources[0].uri)},{})).toEqual({
+  expect(
+    await sseClient.readResource({ uri: result.resources[0].uri }, {}),
+  ).toEqual({
     contents: [
       {
-        uri: "file:///example.txt",
         mimeType: "text/plain",
         text: "This is the content of the example resource.",
+        uri: "file:///example.txt",
       },
     ],
   });
@@ -104,14 +109,13 @@ it("proxies messages between SSE and stdio servers", async () => {
   expect(await sseClient.listResourceTemplates()).toEqual({
     resourceTemplates: [
       {
-        uriTemplate: `file://{filename}`,
-        name: "Example resource template",
         description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
       },
     ],
   });
 
-
   expect(onConnect).toHaveBeenCalled();
   expect(onClose).not.toHaveBeenCalled();
 

package/src/startSSEServer.ts

@@ -1,33 +1,33 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import http from "http";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
 export type SSEServer = {
   close: () => Promise<void>;
 };
 
 type ServerLike = {
-  connect: Server["connect"];
   close: Server["close"];
+  connect: Server["connect"];
 };
 
 export const startSSEServer = async <T extends ServerLike>({
-  port,
   createServer,
   endpoint,
-  onConnect,
   onClose,
+  onConnect,
   onUnhandledRequest,
+  port,
 }: {
-  port: number;
-  endpoint: string;
   createServer: (request: http.IncomingMessage) => Promise<T>;
-  onConnect?: (server: T) => void;
+  endpoint: string;
   onClose?: (server: T) => void;
+  onConnect?: (server: T) => void;
   onUnhandledRequest?: (
     req: http.IncomingMessage,
     res: http.ServerResponse,
   ) => Promise<void>;
+  port: number;
 }): Promise<SSEServer> => {
   const activeTransports: Record<string, SSEServerTransport> = {};
 
@@ -54,13 +54,21 @@ export const startSSEServer = async <T extends ServerLike>({
       return;
     }
 
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "text/plain" }).end("OK");
+      return;
+    }
+
     if (req.method === "GET" && req.url === `/ping`) {
       res.writeHead(200).end("pong");
 
       return;
     }
 
-    if (req.method === "GET" && new URL(req.url!, "http://localhost").pathname === endpoint) {
+    if (
+      req.method === "GET" &&
+      new URL(req.url!, "http://localhost").pathname === endpoint
+    ) {
       const transport = new SSEServerTransport("/messages", res);
 
       let server: T;

package/src/tapTransport.ts

@@ -3,22 +3,22 @@ import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 
 type TransportEvent =
   | {
-      type: "close";
+      error: Error;
+      type: "onerror";
     }
   | {
-      type: "onclose";
+      message: JSONRPCMessage;
+      type: "onmessage";
     }
   | {
-      type: "onerror";
-      error: Error;
+      message: JSONRPCMessage;
+      type: "send";
     }
   | {
-      type: "onmessage";
-      message: JSONRPCMessage;
+      type: "close";
     }
   | {
-      type: "send";
-      message: JSONRPCMessage;
+      type: "onclose";
     }
   | {
       type: "start";
@@ -53,8 +53,8 @@ export const tapTransport = (
 
   transport.onerror = async (error: Error) => {
     eventHandler({
-      type: "onerror",
       error,
+      type: "onerror",
     });
 
     return originalOnError?.(error);
@@ -62,8 +62,8 @@ export const tapTransport = (
 
   transport.onmessage = async (message: JSONRPCMessage) => {
     eventHandler({
-      type: "onmessage",
       message,
+      type: "onmessage",
     });
 
     return originalOnMessage?.(message);
@@ -71,8 +71,8 @@ export const tapTransport = (
 
   transport.send = async (message: JSONRPCMessage) => {
     eventHandler({
-      type: "send",
       message,
+      type: "send",
     });
 
     return originalSend?.(message);