mcp-proxy 1.0.0

package/.github/workflows/feature.yaml

@@ -0,0 +1,37 @@
+name: Run Tests
+on:
+  pull_request:
+    branches:
+      - main
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    name: Test
+    strategy:
+      fail-fast: true
+      matrix:
+        node:
+          - 22
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 9
+      - name: Setup NodeJS ${{ matrix.node }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: "pnpm"
+          cache-dependency-path: "**/pnpm-lock.yaml"
+      - name: Install dependencies
+        run: pnpm install
+      - name: Run tests
+        run: pnpm test

package/.github/workflows/main.yaml

@@ -0,0 +1,48 @@
+name: Release
+on:
+  push:
+    branches:
+      - main
+jobs:
+  test:
+    environment: release
+    name: Test
+    strategy:
+      fail-fast: true
+      matrix:
+        node:
+          - 22
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - name: setup repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 9
+      - name: setup node.js
+        uses: actions/setup-node@v4
+        with:
+          cache: "pnpm"
+          node-version: ${{ matrix.node }}
+      - name: Setup NodeJS ${{ matrix.node }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: "pnpm"
+          cache-dependency-path: "**/pnpm-lock.yaml"
+      - name: Install dependencies
+        run: pnpm install
+      - name: Run tests
+        run: pnpm test
+      - name: Build
+        run: pnpm build
+      - name: Release
+        run: pnpm semantic-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, Frank Fiegel <frank@glama.ai>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,81 @@
+# MCP Proxy
+
+A TypeScript SSE proxy for [MCP](https://modelcontextprotocol.io/) servers that use `stdio` transport.
+
+> [!NOTE]
+> For a Python implementation, see [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy).
+
+> [!NOTE]
+> MCP Proxy is what [FastMCP](https://github.com/punkpeye/fastmcp) uses to enable SSE.
+
+## Installation
+
+```bash
+npm install mcp-proxy
+```
+
+## Quickstart
+
+### Command-line
+
+```bash
+npx mcp-proxy --port 8080 --endpoint /sse tsx server.js
+```
+
+This starts an SSE server and `stdio` server (`tsx server.js`). The SSE server listens on port 8080 and endpoint `/sse`, and forwards messages to the `stdio` server.
+
+### Node.js SDK
+
+The Node.js SDK provides several utilities that are used to create a proxy.
+
+#### `proxyServer`
+
+Sets up a proxy between a server and a client.
+
+```ts
+const transport = new StdioClientTransport();
+const client = new Client();
+
+const server = new Server(serverVersion, {
+  capabilities: {},
+});
+
+proxyServer({
+  server,
+  client,
+  capabilities: {},
+});
+```
+
+In this example, the server will proxy all requests to the client and vice versa.
+
+#### `startSseServer`
+
+Starts a proxy that listens on a `port` and `endpoint`, and sends messages to the attached server via `SSEServerTransport`.
+
+```ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { startSseServer } from "mcp-proxy";
+
+const server = new Server();
+
+const { close } = startSseServer({
+  port: 8080,
+  endpoint: "/sse",
+  server,
+});
+
+close();
+```
+
+#### `tapTransport`
+
+Taps into a transport and logs events.
+
+```ts
+import { tapTransport } from "mcp-proxy";
+
+const transport = tapTransport(new StdioClientTransport(), (event) => {
+  console.log(event);
+});
+```

package/dist/MCPProxy.d.ts

@@ -0,0 +1,36 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ServerCapabilities, JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+type TransportEvent = {
+    type: "close";
+} | {
+    type: "onclose";
+} | {
+    type: "onerror";
+    error: Error;
+} | {
+    type: "onmessage";
+    message: JSONRPCMessage;
+} | {
+    type: "send";
+    message: JSONRPCMessage;
+} | {
+    type: "start";
+};
+declare const tapTransport: (transport: Transport, eventHandler: (event: TransportEvent) => void) => Transport;
+declare const proxyServer: ({ server, client, serverCapabilities, }: {
+    server: Server;
+    client: Client;
+    serverCapabilities: ServerCapabilities;
+}) => Promise<void>;
+declare const startSseServer: ({ port, server, endpoint, }: {
+    port: number;
+    endpoint: string;
+    server: Server;
+}) => {
+    close: () => void;
+};
+
+export { proxyServer, startSseServer, tapTransport };

package/dist/MCPProxy.js

@@ -0,0 +1,11 @@
+import {
+  proxyServer,
+  startSseServer,
+  tapTransport
+} from "./chunk-4AZHVXNQ.js";
+export {
+  proxyServer,
+  startSseServer,
+  tapTransport
+};
+//# sourceMappingURL=MCPProxy.js.map

package/dist/MCPProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/bin/mcp-proxy.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/mcp-proxy.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import {
+  proxyServer,
+  startSseServer
+} from "../chunk-4AZHVXNQ.js";
+
+// src/bin/mcp-proxy.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+var 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
+}).positional("args", {
+  type: "string",
+  array: true,
+  describe: "The arguments to pass to the command"
+}).options({
+  debug: {
+    type: "boolean",
+    describe: "Enable debug logging",
+    default: false
+  },
+  endpoint: {
+    type: "string",
+    describe: "The endpoint to listen on for SSE",
+    default: "/sse"
+  },
+  port: {
+    type: "number",
+    describe: "The port to listen on for SSE",
+    default: 8080
+  }
+}).help().parseAsync();
+var transport = new StdioClientTransport({
+  command: argv.command,
+  args: argv.args,
+  env: process.env
+});
+var client = new Client(
+  {
+    name: "mcp-proxy",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {}
+  }
+);
+await client.connect(transport);
+var serverVersion = client.getServerVersion();
+var serverCapabilities = client.getServerCapabilities();
+var server = new Server(serverVersion, {
+  capabilities: serverCapabilities
+});
+proxyServer({
+  server,
+  client,
+  serverCapabilities
+});
+await startSseServer({
+  server,
+  port: argv.port,
+  endpoint: argv.endpoint
+});
+//# sourceMappingURL=mcp-proxy.js.map

package/dist/bin/mcp-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/mcp-proxy.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport yargs from \"yargs\";\nimport { hideBin } from \"yargs/helpers\";\nimport { StdioClientTransport } from \"@modelcontextprotocol/sdk/client/stdio.js\";\nimport { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { proxyServer, startSseServer } from \"../MCPProxy.js\";\n\nconst argv = await yargs(hideBin(process.argv))\n  .scriptName(\"mcp-proxy\")\n  .command(\"$0 <command> [args...]\", \"Run a command with MCP arguments\")\n  .positional(\"command\", {\n    type: \"string\",\n    describe: \"The command to run\",\n    demandOption: true,\n  })\n  .positional(\"args\", {\n    type: \"string\",\n    array: true,\n    describe: \"The arguments to pass to the command\",\n  })\n  .options({\n    debug: {\n      type: \"boolean\",\n      describe: \"Enable debug logging\",\n      default: false,\n    },\n    endpoint: {\n      type: \"string\",\n      describe: \"The endpoint to listen on for SSE\",\n      default: \"/sse\",\n    },\n    port: {\n      type: \"number\",\n      describe: \"The port to listen on for SSE\",\n      default: 8080,\n    },\n  })\n  .help()\n  .parseAsync();\n\nconst transport = new StdioClientTransport({\n  command: argv.command,\n  args: argv.args,\n  env: process.env as Record<string, string>,\n});\n\nconst client = new Client(\n  {\n    name: \"mcp-proxy\",\n    version: \"1.0.0\",\n  },\n  {\n    capabilities: {},\n  },\n);\n\nawait client.connect(transport);\n\nconst serverVersion = client.getServerVersion() as {\n  name: string;\n  version: string;\n};\n\nconst serverCapabilities = client.getServerCapabilities() as {};\n\nconst server = new Server(serverVersion, {\n  capabilities: serverCapabilities,\n});\n\nproxyServer({\n  server,\n  client,\n  serverCapabilities,\n});\n\nawait startSseServer({\n  server,\n  port: argv.port,\n  endpoint: argv.endpoint as `/${string}`,\n});\n"],"mappings":";;;;;;;AAEA,OAAO,WAAW;AAClB,SAAS,eAAe;AACxB,SAAS,4BAA4B;AACrC,SAAS,cAAc;AACvB,SAAS,cAAc;AAGvB,IAAM,OAAO,MAAM,MAAM,QAAQ,QAAQ,IAAI,CAAC,EAC3C,WAAW,WAAW,EACtB,QAAQ,0BAA0B,kCAAkC,EACpE,WAAW,WAAW;AAAA,EACrB,MAAM;AAAA,EACN,UAAU;AAAA,EACV,cAAc;AAChB,CAAC,EACA,WAAW,QAAQ;AAAA,EAClB,MAAM;AAAA,EACN,OAAO;AAAA,EACP,UAAU;AACZ,CAAC,EACA,QAAQ;AAAA,EACP,OAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,IACV,SAAS;AAAA,EACX;AAAA,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,UAAU;AAAA,IACV,SAAS;AAAA,EACX;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,UAAU;AAAA,IACV,SAAS;AAAA,EACX;AACF,CAAC,EACA,KAAK,EACL,WAAW;AAEd,IAAM,YAAY,IAAI,qBAAqB;AAAA,EACzC,SAAS,KAAK;AAAA,EACd,MAAM,KAAK;AAAA,EACX,KAAK,QAAQ;AACf,CAAC;AAED,IAAM,SAAS,IAAI;AAAA,EACjB;AAAA,IACE,MAAM;AAAA,IACN,SAAS;AAAA,EACX;AAAA,EACA;AAAA,IACE,cAAc,CAAC;AAAA,EACjB;AACF;AAEA,MAAM,OAAO,QAAQ,SAAS;AAE9B,IAAM,gBAAgB,OAAO,iBAAiB;AAK9C,IAAM,qBAAqB,OAAO,sBAAsB;AAExD,IAAM,SAAS,IAAI,OAAO,eAAe;AAAA,EACvC,cAAc;AAChB,CAAC;AAED,YAAY;AAAA,EACV;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,MAAM,eAAe;AAAA,EACnB;AAAA,EACA,MAAM,KAAK;AAAA,EACX,UAAU,KAAK;AACjB,CAAC;","names":[]}

package/dist/chunk-4AZHVXNQ.js

@@ -0,0 +1,199 @@
+// src/MCPProxy.ts
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import http from "http";
+import {
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  LoggingMessageNotificationSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var tapTransport = (transport, eventHandler) => {
+  const originalClose = transport.close.bind(transport);
+  const originalOnClose = transport.onclose?.bind(transport);
+  const originalOnError = transport.onerror?.bind(transport);
+  const originalOnMessage = transport.onmessage?.bind(transport);
+  const originalSend = transport.send.bind(transport);
+  const originalStart = transport.start.bind(transport);
+  transport.close = async () => {
+    eventHandler({
+      type: "close"
+    });
+    return originalClose?.();
+  };
+  transport.onclose = async () => {
+    eventHandler({
+      type: "onclose"
+    });
+    return originalOnClose?.();
+  };
+  transport.onerror = async (error) => {
+    eventHandler({
+      type: "onerror",
+      error
+    });
+    return originalOnError?.(error);
+  };
+  transport.onmessage = async (message) => {
+    eventHandler({
+      type: "onmessage",
+      message
+    });
+    return originalOnMessage?.(message);
+  };
+  transport.send = async (message) => {
+    eventHandler({
+      type: "send",
+      message
+    });
+    return originalSend?.(message);
+  };
+  transport.start = async () => {
+    eventHandler({
+      type: "start"
+    });
+    return originalStart?.();
+  };
+  return transport;
+};
+var proxyServer = async ({
+  server,
+  client,
+  serverCapabilities
+}) => {
+  if (serverCapabilities?.logging) {
+    server.setNotificationHandler(
+      LoggingMessageNotificationSchema,
+      async (args) => {
+        return client.notification(args);
+      }
+    );
+  }
+  if (serverCapabilities?.prompts) {
+    server.setRequestHandler(GetPromptRequestSchema, async (args) => {
+      return client.getPrompt(args.params);
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async (args) => {
+      return client.listPrompts(args.params);
+    });
+  }
+  if (serverCapabilities?.resources) {
+    server.setRequestHandler(ListResourcesRequestSchema, async (args) => {
+      return client.listResources(args.params);
+    });
+    server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async (args) => {
+        return client.listResourceTemplates(args.params);
+      }
+    );
+    server.setRequestHandler(ReadResourceRequestSchema, async (args) => {
+      return client.readResource(args.params);
+    });
+  }
+  if (serverCapabilities?.tools) {
+    server.setRequestHandler(CallToolRequestSchema, async (args) => {
+      return client.callTool(args.params);
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async (args) => {
+      return client.listTools(args.params);
+    });
+  }
+  server.setRequestHandler(CompleteRequestSchema, async (args) => {
+    return client.complete(args.params);
+  });
+};
+var startSending = async (transport) => {
+  try {
+    await transport.send({
+      jsonrpc: "2.0",
+      method: "sse/connection",
+      params: { message: "SSE Connection established" }
+    });
+    let messageCount = 0;
+    const interval = setInterval(async () => {
+      messageCount++;
+      const message = `Message ${messageCount} at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      try {
+        await transport.send({
+          jsonrpc: "2.0",
+          method: "sse/message",
+          params: { data: message }
+        });
+        console.log(`Sent: ${message}`);
+        if (messageCount === 10) {
+          clearInterval(interval);
+          await transport.send({
+            jsonrpc: "2.0",
+            method: "sse/complete",
+            params: { message: "Stream completed" }
+          });
+          console.log("Stream completed");
+        }
+      } catch (error) {
+        console.error("Error sending message:", error);
+        clearInterval(interval);
+      }
+    }, 1e3);
+  } catch (error) {
+    console.error("Error in startSending:", error);
+  }
+};
+var startSseServer = ({
+  port,
+  server,
+  endpoint
+}) => {
+  const activeTransports = {};
+  const httpServer = http.createServer(async (req, res) => {
+    if (req.method === "GET" && req.url === endpoint) {
+      const transport = new SSEServerTransport("/messages", res);
+      activeTransports[transport.sessionId] = transport;
+      await server.connect(transport);
+      res.on("close", () => {
+        console.log("SSE connection closed");
+        delete activeTransports[transport.sessionId];
+      });
+      startSending(transport);
+      return;
+    }
+    if (req.method === "POST" && req.url?.startsWith("/messages")) {
+      const sessionId = new URL(
+        req.url,
+        "https://example.com"
+      ).searchParams.get("sessionId");
+      if (!sessionId) {
+        res.writeHead(400).end("No sessionId");
+        return;
+      }
+      const activeTransport = activeTransports[sessionId];
+      if (!activeTransport) {
+        res.writeHead(400).end("No active transport");
+        return;
+      }
+      await activeTransport.handlePostMessage(req, res);
+      return;
+    }
+    res.writeHead(404).end();
+  });
+  httpServer.listen(port, "0.0.0.0");
+  console.error(
+    `server is running on SSE at http://localhost:${port}${endpoint}`
+  );
+  return {
+    close: () => {
+      httpServer.close();
+    }
+  };
+};
+
+export {
+  tapTransport,
+  proxyServer,
+  startSseServer
+};
+//# sourceMappingURL=chunk-4AZHVXNQ.js.map

package/dist/chunk-4AZHVXNQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/MCPProxy.ts"],"sourcesContent":["import { SSEServerTransport } from \"@modelcontextprotocol/sdk/server/sse.js\";\nimport http from \"http\";\nimport { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport {\n  CallToolRequestSchema,\n  CompleteRequestSchema,\n  GetPromptRequestSchema,\n  JSONRPCMessage,\n  ListPromptsRequestSchema,\n  ListResourcesRequestSchema,\n  ListResourceTemplatesRequestSchema,\n  ListToolsRequestSchema,\n  LoggingMessageNotificationSchema,\n  ReadResourceRequestSchema,\n  ServerCapabilities,\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport { Transport } from \"@modelcontextprotocol/sdk/shared/transport.js\";\nimport { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\n\ntype TransportEvent =\n  | {\n      type: \"close\";\n    }\n  | {\n      type: \"onclose\";\n    }\n  | {\n      type: \"onerror\";\n      error: Error;\n    }\n  | {\n      type: \"onmessage\";\n      message: JSONRPCMessage;\n    }\n  | {\n      type: \"send\";\n      message: JSONRPCMessage;\n    }\n  | {\n      type: \"start\";\n    };\n\nexport const tapTransport = (\n  transport: Transport,\n  eventHandler: (event: TransportEvent) => void,\n) => {\n  const originalClose = transport.close.bind(transport);\n  const originalOnClose = transport.onclose?.bind(transport);\n  const originalOnError = transport.onerror?.bind(transport);\n  const originalOnMessage = transport.onmessage?.bind(transport);\n  const originalSend = transport.send.bind(transport);\n  const originalStart = transport.start.bind(transport);\n\n  transport.close = async () => {\n    eventHandler({\n      type: \"close\",\n    });\n\n    return originalClose?.();\n  };\n\n  transport.onclose = async () => {\n    eventHandler({\n      type: \"onclose\",\n    });\n\n    return originalOnClose?.();\n  };\n\n  transport.onerror = async (error: Error) => {\n    eventHandler({\n      type: \"onerror\",\n      error,\n    });\n\n    return originalOnError?.(error);\n  };\n\n  transport.onmessage = async (message: JSONRPCMessage) => {\n    eventHandler({\n      type: \"onmessage\",\n      message,\n    });\n\n    return originalOnMessage?.(message);\n  };\n\n  transport.send = async (message: JSONRPCMessage) => {\n    eventHandler({\n      type: \"send\",\n      message,\n    });\n\n    return originalSend?.(message);\n  };\n\n  transport.start = async () => {\n    eventHandler({\n      type: \"start\",\n    });\n\n    return originalStart?.();\n  };\n\n  return transport;\n};\n\nexport const proxyServer = async ({\n  server,\n  client,\n  serverCapabilities,\n}: {\n  server: Server;\n  client: Client;\n  serverCapabilities: ServerCapabilities;\n}) => {\n  if (serverCapabilities?.logging) {\n    server.setNotificationHandler(\n      LoggingMessageNotificationSchema,\n      async (args) => {\n        return client.notification(args);\n      },\n    );\n  }\n\n  if (serverCapabilities?.prompts) {\n    server.setRequestHandler(GetPromptRequestSchema, async (args) => {\n      return client.getPrompt(args.params);\n    });\n\n    server.setRequestHandler(ListPromptsRequestSchema, async (args) => {\n      return client.listPrompts(args.params);\n    });\n  }\n\n  if (serverCapabilities?.resources) {\n    server.setRequestHandler(ListResourcesRequestSchema, async (args) => {\n      return client.listResources(args.params);\n    });\n\n    server.setRequestHandler(\n      ListResourceTemplatesRequestSchema,\n      async (args) => {\n        return client.listResourceTemplates(args.params);\n      },\n    );\n\n    server.setRequestHandler(ReadResourceRequestSchema, async (args) => {\n      return client.readResource(args.params);\n    });\n  }\n\n  if (serverCapabilities?.tools) {\n    server.setRequestHandler(CallToolRequestSchema, async (args) => {\n      return client.callTool(args.params);\n    });\n\n    server.setRequestHandler(ListToolsRequestSchema, async (args) => {\n      return client.listTools(args.params);\n    });\n  }\n\n  server.setRequestHandler(CompleteRequestSchema, async (args) => {\n    return client.complete(args.params);\n  });\n};\n\n/**\n * @author https://dev.classmethod.jp/articles/mcp-sse/\n */\nconst startSending = async (transport: SSEServerTransport) => {\n  try {\n    await transport.send({\n      jsonrpc: \"2.0\",\n      method: \"sse/connection\",\n      params: { message: \"SSE Connection established\" },\n    });\n\n    let messageCount = 0;\n    const interval = setInterval(async () => {\n      messageCount++;\n\n      const message = `Message ${messageCount} at ${new Date().toISOString()}`;\n\n      try {\n        await transport.send({\n          jsonrpc: \"2.0\",\n          method: \"sse/message\",\n          params: { data: message },\n        });\n\n        console.log(`Sent: ${message}`);\n\n        if (messageCount === 10) {\n          clearInterval(interval);\n\n          await transport.send({\n            jsonrpc: \"2.0\",\n            method: \"sse/complete\",\n            params: { message: \"Stream completed\" },\n          });\n          console.log(\"Stream completed\");\n        }\n      } catch (error) {\n        console.error(\"Error sending message:\", error);\n        clearInterval(interval);\n      }\n    }, 1000);\n  } catch (error) {\n    console.error(\"Error in startSending:\", error);\n  }\n};\n\nexport const startSseServer = ({\n  port,\n  server,\n  endpoint,\n}: {\n  port: number;\n  endpoint: string;\n  server: Server;\n}) => {\n  const activeTransports: Record<string, SSEServerTransport> = {};\n\n  /**\n   * @author https://dev.classmethod.jp/articles/mcp-sse/\n   */\n  const httpServer = http.createServer(async (req, res) => {\n    if (req.method === \"GET\" && req.url === endpoint) {\n      const transport = new SSEServerTransport(\"/messages\", res);\n\n      activeTransports[transport.sessionId] = transport;\n\n      await server.connect(transport);\n\n      res.on(\"close\", () => {\n        console.log(\"SSE connection closed\");\n\n        delete activeTransports[transport.sessionId];\n      });\n\n      startSending(transport);\n\n      return;\n    }\n\n    if (req.method === \"POST\" && req.url?.startsWith(\"/messages\")) {\n      const sessionId = new URL(\n        req.url,\n        \"https://example.com\",\n      ).searchParams.get(\"sessionId\");\n\n      if (!sessionId) {\n        res.writeHead(400).end(\"No sessionId\");\n\n        return;\n      }\n\n      const activeTransport: SSEServerTransport | undefined =\n        activeTransports[sessionId];\n\n      if (!activeTransport) {\n        res.writeHead(400).end(\"No active transport\");\n\n        return;\n      }\n\n      await activeTransport.handlePostMessage(req, res);\n\n      return;\n    }\n\n    res.writeHead(404).end();\n  });\n\n  httpServer.listen(port, \"0.0.0.0\");\n\n  console.error(\n    `server is running on SSE at http://localhost:${port}${endpoint}`,\n  );\n\n  return {\n    close: () => {\n      httpServer.close();\n    },\n  };\n};\n"],"mappings":"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","names":[]}

package/eslint.config.js

@@ -0,0 +1,3 @@
+import perfectionist from "eslint-plugin-perfectionist";
+
+export default [perfectionist.configs["recommended-alphabetical"]];

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "mcp-proxy",
+  "version": "1.0.0",
+  "main": "dist/MCPProxy.js",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run && tsc",
+    "format": "prettier --write . && eslint --fix ."
+  },
+  "bin": {
+    "mcp-proxy": "dist/bin/mcp-proxy.js"
+  },
+  "keywords": [
+    "MCP",
+    "SSE",
+    "proxy"
+  ],
+  "type": "module",
+  "author": "Frank Fiegel <frank@glama.ai>",
+  "license": "MIT",
+  "description": "A TypeScript SSE proxy for MCP servers that use stdio transport.",
+  "module": "dist/MCPProxy.js",
+  "types": "dist/MCPProxy.d.ts",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "fastmcp": "^1.5.9",
+    "yargs": "^17.7.2"
+  },
+  "repository": {
+    "url": "https://github.com/punkpeye/mcp-proxy"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  },
+  "devDependencies": {
+    "@sebbo2002/semantic-release-jsr": "^2.0.2",
+    "@tsconfig/node22": "^22.0.0",
+    "@types/node": "^22.10.2",
+    "@types/yargs": "^17.0.33",
+    "eslint": "^9.17.0",
+    "eslint-plugin-perfectionist": "^4.4.0",
+    "eventsource": "^3.0.2",
+    "get-port-please": "^3.1.2",
+    "prettier": "^3.4.2",
+    "semantic-release": "^24.2.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "tsup": {
+    "entry": [
+      "src/MCPProxy.ts",
+      "src/bin/mcp-proxy.ts"
+    ],
+    "format": [
+      "esm"
+    ],
+    "dts": true,
+    "splitting": true,
+    "sourcemap": true,
+    "clean": true
+  }
+}

package/src/MCPProxy.test.ts

@@ -0,0 +1,80 @@
+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 } from "vitest";
+import { proxyServer, startSseServer } from "./MCPProxy.js";
+import { getRandomPort } from "get-port-please";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { EventSource } from "eventsource";
+
+// @ts-expect-error - figure out how to use --experimental-eventsource with vitest
+global.EventSource = EventSource;
+
+it("proxies messages between SSE and stdio servers", async () => {
+  const stdioTransport = new StdioClientTransport({
+    command: "tsx",
+    args: ["src/simple-stdio-server.ts"],
+  });
+
+  const stdioClient = new Client(
+    {
+      name: "mcp-proxy",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  await stdioClient.connect(stdioTransport);
+
+  const serverVersion = stdioClient.getServerVersion() as {
+    name: string;
+    version: string;
+  };
+
+  const serverCapabilities = stdioClient.getServerCapabilities() as {};
+
+  const sseServer = new Server(serverVersion, {
+    capabilities: serverCapabilities,
+  });
+
+  proxyServer({
+    server: sseServer,
+    client: stdioClient,
+    serverCapabilities,
+  });
+
+  const port = await getRandomPort();
+
+  await startSseServer({
+    server: sseServer,
+    port,
+    endpoint: "/sse",
+  });
+
+  const sseClient = new Client(
+    {
+      name: "sse-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  const transport = new SSEClientTransport(
+    new URL(`http://localhost:${port}/sse`),
+  );
+
+  await sseClient.connect(transport);
+
+  expect(await sseClient.listResources()).toEqual({
+    resources: [
+      {
+        uri: "file:///example.txt",
+        name: "Example Resource",
+      },
+    ],
+  });
+});

package/src/MCPProxy.ts

@@ -0,0 +1,287 @@
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import http from "http";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  GetPromptRequestSchema,
+  JSONRPCMessage,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  LoggingMessageNotificationSchema,
+  ReadResourceRequestSchema,
+  ServerCapabilities,
+} from "@modelcontextprotocol/sdk/types.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+type TransportEvent =
+  | {
+      type: "close";
+    }
+  | {
+      type: "onclose";
+    }
+  | {
+      type: "onerror";
+      error: Error;
+    }
+  | {
+      type: "onmessage";
+      message: JSONRPCMessage;
+    }
+  | {
+      type: "send";
+      message: JSONRPCMessage;
+    }
+  | {
+      type: "start";
+    };
+
+export const tapTransport = (
+  transport: Transport,
+  eventHandler: (event: TransportEvent) => void,
+) => {
+  const originalClose = transport.close.bind(transport);
+  const originalOnClose = transport.onclose?.bind(transport);
+  const originalOnError = transport.onerror?.bind(transport);
+  const originalOnMessage = transport.onmessage?.bind(transport);
+  const originalSend = transport.send.bind(transport);
+  const originalStart = transport.start.bind(transport);
+
+  transport.close = async () => {
+    eventHandler({
+      type: "close",
+    });
+
+    return originalClose?.();
+  };
+
+  transport.onclose = async () => {
+    eventHandler({
+      type: "onclose",
+    });
+
+    return originalOnClose?.();
+  };
+
+  transport.onerror = async (error: Error) => {
+    eventHandler({
+      type: "onerror",
+      error,
+    });
+
+    return originalOnError?.(error);
+  };
+
+  transport.onmessage = async (message: JSONRPCMessage) => {
+    eventHandler({
+      type: "onmessage",
+      message,
+    });
+
+    return originalOnMessage?.(message);
+  };
+
+  transport.send = async (message: JSONRPCMessage) => {
+    eventHandler({
+      type: "send",
+      message,
+    });
+
+    return originalSend?.(message);
+  };
+
+  transport.start = async () => {
+    eventHandler({
+      type: "start",
+    });
+
+    return originalStart?.();
+  };
+
+  return transport;
+};
+
+export const proxyServer = async ({
+  server,
+  client,
+  serverCapabilities,
+}: {
+  server: Server;
+  client: Client;
+  serverCapabilities: ServerCapabilities;
+}) => {
+  if (serverCapabilities?.logging) {
+    server.setNotificationHandler(
+      LoggingMessageNotificationSchema,
+      async (args) => {
+        return client.notification(args);
+      },
+    );
+  }
+
+  if (serverCapabilities?.prompts) {
+    server.setRequestHandler(GetPromptRequestSchema, async (args) => {
+      return client.getPrompt(args.params);
+    });
+
+    server.setRequestHandler(ListPromptsRequestSchema, async (args) => {
+      return client.listPrompts(args.params);
+    });
+  }
+
+  if (serverCapabilities?.resources) {
+    server.setRequestHandler(ListResourcesRequestSchema, async (args) => {
+      return client.listResources(args.params);
+    });
+
+    server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async (args) => {
+        return client.listResourceTemplates(args.params);
+      },
+    );
+
+    server.setRequestHandler(ReadResourceRequestSchema, async (args) => {
+      return client.readResource(args.params);
+    });
+  }
+
+  if (serverCapabilities?.tools) {
+    server.setRequestHandler(CallToolRequestSchema, async (args) => {
+      return client.callTool(args.params);
+    });
+
+    server.setRequestHandler(ListToolsRequestSchema, async (args) => {
+      return client.listTools(args.params);
+    });
+  }
+
+  server.setRequestHandler(CompleteRequestSchema, async (args) => {
+    return client.complete(args.params);
+  });
+};
+
+/**
+ * @author https://dev.classmethod.jp/articles/mcp-sse/
+ */
+const startSending = async (transport: SSEServerTransport) => {
+  try {
+    await transport.send({
+      jsonrpc: "2.0",
+      method: "sse/connection",
+      params: { message: "SSE Connection established" },
+    });
+
+    let messageCount = 0;
+    const interval = setInterval(async () => {
+      messageCount++;
+
+      const message = `Message ${messageCount} at ${new Date().toISOString()}`;
+
+      try {
+        await transport.send({
+          jsonrpc: "2.0",
+          method: "sse/message",
+          params: { data: message },
+        });
+
+        console.log(`Sent: ${message}`);
+
+        if (messageCount === 10) {
+          clearInterval(interval);
+
+          await transport.send({
+            jsonrpc: "2.0",
+            method: "sse/complete",
+            params: { message: "Stream completed" },
+          });
+          console.log("Stream completed");
+        }
+      } catch (error) {
+        console.error("Error sending message:", error);
+        clearInterval(interval);
+      }
+    }, 1000);
+  } catch (error) {
+    console.error("Error in startSending:", error);
+  }
+};
+
+export const startSseServer = ({
+  port,
+  server,
+  endpoint,
+}: {
+  port: number;
+  endpoint: string;
+  server: Server;
+}) => {
+  const activeTransports: Record<string, SSEServerTransport> = {};
+
+  /**
+   * @author https://dev.classmethod.jp/articles/mcp-sse/
+   */
+  const httpServer = http.createServer(async (req, res) => {
+    if (req.method === "GET" && req.url === endpoint) {
+      const transport = new SSEServerTransport("/messages", res);
+
+      activeTransports[transport.sessionId] = transport;
+
+      await server.connect(transport);
+
+      res.on("close", () => {
+        console.log("SSE connection closed");
+
+        delete activeTransports[transport.sessionId];
+      });
+
+      startSending(transport);
+
+      return;
+    }
+
+    if (req.method === "POST" && req.url?.startsWith("/messages")) {
+      const sessionId = new URL(
+        req.url,
+        "https://example.com",
+      ).searchParams.get("sessionId");
+
+      if (!sessionId) {
+        res.writeHead(400).end("No sessionId");
+
+        return;
+      }
+
+      const activeTransport: SSEServerTransport | undefined =
+        activeTransports[sessionId];
+
+      if (!activeTransport) {
+        res.writeHead(400).end("No active transport");
+
+        return;
+      }
+
+      await activeTransport.handlePostMessage(req, res);
+
+      return;
+    }
+
+    res.writeHead(404).end();
+  });
+
+  httpServer.listen(port, "0.0.0.0");
+
+  console.error(
+    `server is running on SSE at http://localhost:${port}${endpoint}`,
+  );
+
+  return {
+    close: () => {
+      httpServer.close();
+    },
+  };
+};

package/src/bin/mcp-proxy.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { proxyServer, startSseServer } from "../MCPProxy.js";
+
+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,
+  })
+  .positional("args", {
+    type: "string",
+    array: true,
+    describe: "The arguments to pass to the command",
+  })
+  .options({
+    debug: {
+      type: "boolean",
+      describe: "Enable debug logging",
+      default: false,
+    },
+    endpoint: {
+      type: "string",
+      describe: "The endpoint to listen on for SSE",
+      default: "/sse",
+    },
+    port: {
+      type: "number",
+      describe: "The port to listen on for SSE",
+      default: 8080,
+    },
+  })
+  .help()
+  .parseAsync();
+
+const transport = new StdioClientTransport({
+  command: argv.command,
+  args: argv.args,
+  env: process.env as Record<string, string>,
+});
+
+const client = new Client(
+  {
+    name: "mcp-proxy",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {},
+  },
+);
+
+await client.connect(transport);
+
+const serverVersion = client.getServerVersion() as {
+  name: string;
+  version: string;
+};
+
+const serverCapabilities = client.getServerCapabilities() as {};
+
+const server = new Server(serverVersion, {
+  capabilities: serverCapabilities,
+});
+
+proxyServer({
+  server,
+  client,
+  serverCapabilities,
+});
+
+await startSseServer({
+  server,
+  port: argv.port,
+  endpoint: argv.endpoint as `/${string}`,
+});

package/src/simple-stdio-server.ts

@@ -0,0 +1,49 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const server = new Server(
+  {
+    name: "example-server",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      resources: {},
+    },
+  },
+);
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "file:///example.txt",
+        name: "Example Resource",
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  if (request.params.uri === "file:///example.txt") {
+    return {
+      contents: [
+        {
+          uri: "file:///example.txt",
+          mimeType: "text/plain",
+          text: "This is the content of the example resource.",
+        },
+      ],
+    };
+  } else {
+    throw new Error("Resource not found");
+  }
+});
+
+const transport = new StdioServerTransport();
+
+await server.connect(transport);

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@tsconfig/node22/tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  }
+}