mcp-proxy 2.8.1 → 2.9.0

package/src/StdioClientTransport.ts

@@ -0,0 +1,226 @@
+/**
+ * Forked from https://github.com/modelcontextprotocol/typescript-sdk/blob/66e1508162d37c0b83b0637ebcd7f07946e3d210/src/client/stdio.ts#L90
+ */
+
+import {
+  ReadBuffer,
+  serializeMessage,
+} from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import { ChildProcess, IOType, spawn } from "node:child_process";
+import { Stream } from "node:stream";
+
+type TransportEvent =
+  | {
+      type: "close";
+    }
+  | {
+      type: "error";
+      error: Error;
+    }
+  | {
+      type: "data";
+      chunk: string;
+    }
+  | {
+      type: "message";
+      message: JSONRPCMessage;
+    };
+
+export type StdioServerParameters = {
+  /**
+   * The executable to run to start the server.
+   */
+  command: string;
+
+  /**
+   * Command line arguments to pass to the executable.
+   */
+  args?: string[];
+
+  /**
+   * The environment to use when spawning the process.
+   *
+   * If not specified, the result of getDefaultEnvironment() will be used.
+   */
+  env: Record<string, string>;
+
+  /**
+   * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.
+   *
+   * The default is "inherit", meaning messages to stderr will be printed to the parent process's stderr.
+   */
+  stderr?: IOType | Stream | number;
+
+  /**
+   * The working directory to use when spawning the process.
+   *
+   * If not specified, the current working directory will be inherited.
+   */
+  cwd?: string;
+
+  /**
+   * A function to call when an event occurs.
+   */
+  onEvent?: (event: TransportEvent) => void;
+};
+
+/**
+ * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+ *
+ * This transport is only available in Node.js environments.
+ */
+export class StdioClientTransport implements Transport {
+  private process?: ChildProcess;
+  private abortController: AbortController = new AbortController();
+  private readBuffer: ReadBuffer = new ReadBuffer();
+  private serverParams: StdioServerParameters;
+  private onEvent?: (event: TransportEvent) => void;
+
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+
+  constructor(server: StdioServerParameters) {
+    this.serverParams = server;
+    this.onEvent = server.onEvent;
+  }
+
+  /**
+   * Starts the server process and prepares to communicate with it.
+   */
+  async start(): Promise<void> {
+    if (this.process) {
+      throw new Error(
+        "StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.",
+      );
+    }
+
+    return new Promise((resolve, reject) => {
+      this.process = spawn(
+        this.serverParams.command,
+        this.serverParams.args ?? [],
+        {
+          env: this.serverParams.env,
+          stdio: ["pipe", "pipe", this.serverParams.stderr ?? "inherit"],
+          shell: false,
+          signal: this.abortController.signal,
+          cwd: this.serverParams.cwd,
+        },
+      );
+
+      this.process.on("error", (error) => {
+        if (error.name === "AbortError") {
+          // Expected when close() is called.
+          this.onclose?.();
+          return;
+        }
+
+        reject(error);
+        this.onerror?.(error);
+      });
+
+      this.process.on("spawn", () => {
+        resolve();
+      });
+
+      this.process.on("close", (_code) => {
+        this.onEvent?.({
+          type: "close",
+        });
+
+        this.process = undefined;
+        this.onclose?.();
+      });
+
+      this.process.stdin?.on("error", (error) => {
+        this.onEvent?.({
+          type: "error",
+          error,
+        });
+
+        this.onerror?.(error);
+      });
+
+      this.process.stdout?.on("data", (chunk) => {
+        this.onEvent?.({
+          type: "data",
+          chunk: chunk.toString(),
+        });
+
+        this.readBuffer.append(chunk);
+        this.processReadBuffer();
+      });
+
+      this.process.stdout?.on("error", (error) => {
+        this.onEvent?.({
+          type: "error",
+          error,
+        });
+
+        this.onerror?.(error);
+      });
+    });
+  }
+
+  /**
+   * The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped".
+   *
+   * This is only available after the process has been started.
+   */
+  get stderr(): Stream | null {
+    return this.process?.stderr ?? null;
+  }
+
+  private processReadBuffer() {
+    while (true) {
+      try {
+        const message = this.readBuffer.readMessage();
+
+        if (message === null) {
+          break;
+        }
+
+        this.onEvent?.({
+          type: "message",
+          message,
+        });
+
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onEvent?.({
+          type: "error",
+          error: error as Error,
+        });
+
+        this.onerror?.(error as Error);
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.onEvent?.({
+      type: "close",
+    });
+
+    this.abortController.abort();
+    this.process = undefined;
+    this.readBuffer.clear();
+  }
+
+  send(message: JSONRPCMessage): Promise<void> {
+    return new Promise((resolve) => {
+      if (!this.process?.stdin) {
+        throw new Error("Not connected");
+      }
+
+      const json = serializeMessage(message);
+      if (this.process.stdin.write(json)) {
+        resolve();
+      } else {
+        this.process.stdin.once("drain", resolve);
+      }
+    });
+  }
+}

package/src/bin/mcp-proxy.ts

@@ -2,13 +2,16 @@
 
 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";
 import { EventSource } from "eventsource";
 import { setTimeout } from "node:timers/promises";
-import multiline from 'multiline-ts';
+import { StdioClientTransport } from "../StdioClientTransport.js";
+import util from "node:util";
+import { startSSEServer } from "../startSSEServer.js";
+import { proxyServer } from "../proxyServer.js";
+
+util.inspect.defaultOptions.depth = 8;
 
 if (!("EventSource" in global)) {
   // @ts-expect-error - figure out how to use --experimental-eventsource with vitest
@@ -48,85 +51,71 @@ const argv = await yargs(hideBin(process.argv))
   .help()
   .parseAsync();
 
-const transport = new StdioClientTransport({
-  command: argv.command,
-  args: argv.args,
-  env: process.env as Record<string, string>,
-  stderr: 'pipe',
-});
-
-const client = new Client(
-  {
-    name: "mcp-proxy",
-    version: "1.0.0",
-  },
-  {
-    capabilities: {},
-  },
-);
-
-
-let stderrOutput = '';
-
-try {
-  console.info('connecting to the MCP server...');
-
-  const connectionPromise = client.connect(transport);
-
-  transport?.stderr?.on('data', (chunk) => {
-    stderrOutput += chunk.toString();
+const connect = async (client: Client) => {
+  const transport = new StdioClientTransport({
+    command: argv.command,
+    args: argv.args,
+    env: process.env as Record<string, string>,
+    stderr: "pipe",
+    onEvent: (event) => {
+      console.debug("transport event", event);
+    },
   });
 
-  await connectionPromise;
-
-  console.info('connected to the MCP server');
-} catch (error) {
-  console.error(multiline`
-    could not connect to the MCP server
-
-    --- error ---
-    ${String(error)}
-
-    --- stderr output ---
-    ${stderrOutput}
-`);
+  await client.connect(transport);
+};
 
-  await setTimeout(1000);
+const proxy = async () => {
+  const client = new Client(
+    {
+      name: "mcp-proxy",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
 
-  process.exit(1);
-}
+  await connect(client);
 
-const serverVersion = client.getServerVersion() as {
-  name: string;
-  version: string;
-};
+  const serverVersion = client.getServerVersion() as {
+    name: string;
+    version: string;
+  };
 
-const serverCapabilities = client.getServerCapabilities() as {};
+  const serverCapabilities = client.getServerCapabilities() as {};
 
-try {
-  console.info('starting the SSE server on port %d', argv.port);
+  console.info("starting the SSE server on port %d", argv.port);
 
   await startSSEServer({
     createServer: async () => {
       const server = new Server(serverVersion, {
         capabilities: serverCapabilities,
       });
-  
+
       proxyServer({
         server,
         client,
         serverCapabilities,
       });
-  
+
       return server;
     },
     port: argv.port,
     endpoint: argv.endpoint as `/${string}`,
   });
-} catch (error) {
-  console.error('could not start the SSE server', error);
+};
 
-  await setTimeout(1000);
+const main = async () => {
+  try {
+    await proxy();
+  } catch (error) {
+    console.error("could not start the proxy", error);
 
-  process.exit(1);
-}
+    await setTimeout(1000);
+
+    process.exit(1);
+  }
+};
+
+await main();

package/src/index.ts

@@ -0,0 +1,3 @@
+export { tapTransport } from "./tapTransport.js";
+export { proxyServer } from "./proxyServer.js";
+export { startSSEServer } from "./startSSEServer.js";

package/src/proxyServer.ts

@@ -0,0 +1,74 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  LoggingMessageNotificationSchema,
+  ReadResourceRequestSchema,
+  ServerCapabilities,
+} from "@modelcontextprotocol/sdk/types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+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);
+  });
+};

package/src/{MCPProxy.test.ts → startSSEServer.test.ts}

@@ -2,11 +2,12 @@ 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 { proxyServer, startSSEServer } from "./MCPProxy.js";
+import { startSSEServer } from "./startSSEServer.js";
 import { getRandomPort } from "get-port-please";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { EventSource } from "eventsource";
 import { setTimeout as delay } from "node:timers/promises";
+import { proxyServer } from "./proxyServer.js";
 
 if (!("EventSource" in global)) {
   // @ts-expect-error - figure out how to use --experimental-eventsource with vitest

package/src/{MCPProxy.ts → startSSEServer.ts}

@@ -1,169 +1,6 @@
 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);
-  });
-};
 
 export type SSEServer = {
   close: () => Promise<void>;
@@ -268,7 +105,7 @@ export const startSSEServer = async <T extends ServerLike>({
       } catch (error) {
         if (!closed) {
           console.error("Error connecting to server:", error);
-          
+
           res.writeHead(500).end("Error connecting to server");
         }
       }