mcp-proxy 6.4.2 → 6.4.3

package/jsr.json

@@ -3,5 +3,5 @@
   "include": ["src/index.ts", "src/bin/mcp-proxy.ts"],
   "license": "MIT",
   "name": "@punkpeye/mcp-proxy",
-  "version": "6.4.2"
+  "version": "6.4.3"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-proxy",
-  "version": "6.4.2",
+  "version": "6.4.3",
   "main": "dist/index.mjs",
   "scripts": {
     "build": "tsdown",

package/src/JSONFilterTransform.test.ts

@@ -41,7 +41,7 @@ describe("JSONFilterTransform", () => {
     expect(outputLines).toHaveLength(4);
     expect(outputLines[0]).toBe('{"type": "request", "id": 1}');
     expect(outputLines[1]).toBe('{"type": "response", "id": 2}');
-    expect(outputLines[2]).toBe('  {"type": "notification"}  ');
+    expect(outputLines[2]).toBe('{"type": "notification"}');
     expect(outputLines[3]).toBe('{"type": "request", "id": 3}');
 
     // Should have warned about non-JSON lines
@@ -50,7 +50,6 @@ describe("JSONFilterTransform", () => {
       expect.arrayContaining([
         "This is not JSON",
         "Another non-JSON line",
-        "",
         "Error: something went wrong",
       ]),
     );
@@ -58,6 +57,52 @@ describe("JSONFilterTransform", () => {
     consoleWarnSpy.mockRestore();
   });
 
+  it("extracts JSON from lines with non-JSON prefixes", async () => {
+    const input = [
+      'Loading...{"type": "request", "id": 1}',
+      'WARNING: deprecation{"type": "response", "id": 2}',
+      '{"type": "clean", "id": 3}',
+      "Pure noise with no JSON",
+    ].join("\n");
+
+    const consoleWarnSpy = vi
+      .spyOn(console, "warn")
+      .mockImplementation(() => {});
+
+    const readable = Readable.from([input]);
+    const transform = new JSONFilterTransform();
+    const chunks: Buffer[] = [];
+
+    const writable = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      },
+    });
+
+    await pipeline(readable, transform, writable);
+
+    const output = Buffer.concat(chunks).toString();
+    const outputLines = output.trim().split("\n");
+
+    expect(outputLines).toHaveLength(3);
+    expect(outputLines[0]).toBe('{"type": "request", "id": 1}');
+    expect(outputLines[1]).toBe('{"type": "response", "id": 2}');
+    expect(outputLines[2]).toBe('{"type": "clean", "id": 3}');
+
+    // Should have warned about stripped prefixes
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "[mcp-proxy] stripped non-JSON prefix from output:",
+      "Loading...",
+    );
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      "[mcp-proxy] stripped non-JSON prefix from output:",
+      "WARNING: deprecation",
+    );
+
+    consoleWarnSpy.mockRestore();
+  });
+
   it("handles incomplete JSON lines across multiple chunks", async () => {
     // Simulate data arriving in chunks where JSON lines are split
     const chunks = [

package/src/JSONFilterTransform.ts

@@ -1,8 +1,12 @@
 import { Transform } from "node:stream";
 
 /**
- * Filters out lines that do not start with '{' from the input stream.
- * We use this to drop anything that is obviously not a JSON-RPC message.
+ * Extracts JSON-RPC messages from a stream that may contain non-JSON output.
+ *
+ * Lines that start with '{' are passed through as-is. Lines that contain '{'
+ * but have a non-JSON prefix (e.g. Python warnings prepended to a JSON message)
+ * have the prefix stripped and the JSON portion extracted. Lines with no '{'
+ * are dropped entirely.
  */
 export class JSONFilterTransform extends Transform {
   private buffer = "";
@@ -13,8 +17,9 @@ export class JSONFilterTransform extends Transform {
 
   _flush(callback: (error: Error | null, chunk: Buffer | null) => void) {
     // Handle any remaining data in buffer
-    if (this.buffer.trim().startsWith("{")) {
-      callback(null, Buffer.from(this.buffer));
+    const json = extractJson(this.buffer);
+    if (json !== null) {
+      callback(null, Buffer.from(json));
     } else {
       callback(null, null);
     }
@@ -31,14 +36,14 @@ export class JSONFilterTransform extends Transform {
     // Keep the last incomplete line in the buffer
     this.buffer = lines.pop() || "";
 
-    // Filter lines that start with '{'
     const jsonLines = [];
     const nonJsonLines = [];
 
     for (const line of lines) {
-      if (line.trim().startsWith("{")) {
-        jsonLines.push(line);
-      } else {
+      const json = extractJson(line);
+      if (json !== null) {
+        jsonLines.push(json);
+      } else if (line.trim().length > 0) {
         nonJsonLines.push(line);
       }
     }
@@ -57,3 +62,31 @@ export class JSONFilterTransform extends Transform {
     }
   }
 }
+
+/**
+ * Extracts the JSON portion from a line that may have a non-JSON prefix.
+ * Returns null if the line contains no '{'.
+ */
+function extractJson(line: string): null | string {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+
+  const braceIndex = trimmed.indexOf("{");
+  if (braceIndex === -1) {
+    return null;
+  }
+
+  if (braceIndex === 0) {
+    return trimmed;
+  }
+
+  // There's a non-JSON prefix — strip it and return from the first '{'
+  const jsonPart = trimmed.slice(braceIndex);
+  console.warn(
+    "[mcp-proxy] stripped non-JSON prefix from output:",
+    trimmed.slice(0, braceIndex),
+  );
+  return jsonPart;
+}

package/src/fixtures/noisy-stdout-server.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env tsx
+/**
+ * Simulates a Python-like MCP server that emits non-JSON output to stdout
+ * before and during startup. This mimics the behavior of Python servers
+ * where warnings, import messages, or unbuffered print() calls can
+ * pollute the stdout stream that mcp-proxy reads as JSON-RPC.
+ *
+ * Related: https://github.com/punkpeye/mcp-proxy/issues/55
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+// Simulate non-JSON output on stdout before the server starts,
+// like Python import warnings or startup messages
+const noiseBefore = process.env.NOISE_BEFORE;
+if (noiseBefore) {
+  process.stdout.write(noiseBefore);
+}
+
+const server = new Server(
+  {
+    name: "noisy-stdout-server",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  // Simulate noise interleaved with normal responses
+  const noiseDuring = process.env.NOISE_DURING;
+  if (noiseDuring) {
+    process.stdout.write(noiseDuring);
+  }
+
+  return {
+    tools: [
+      {
+        description: "A test tool",
+        inputSchema: {
+          properties: {},
+          type: "object",
+        },
+        name: "ping",
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async () => {
+  return {
+    content: [
+      {
+        text: "pong",
+        type: "text" as const,
+      },
+    ],
+  };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);