@diegoaltoworks/localize-remote-mcp-server 1.0.0

package/bin/cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util";
+import { createProxy } from "../src/proxy.js";
+
+const { values, positionals } = parseArgs({
+  options: {
+    port: { type: "string", short: "p", default: "3000" },
+    help: { type: "boolean", short: "h", default: false },
+  },
+  allowPositionals: true,
+});
+
+if (values.help || positionals.length === 0) {
+  console.log(`
+Usage: localize-remote-mcp-server [options] <remote-url>
+
+Proxy a remote HTTP MCP server to localhost.
+
+Options:
+  -p, --port <port>  Local port to listen on (default: 3000)
+  -h, --help         Show this help message
+
+Example:
+  npx @diegoaltoworks/localize-remote-mcp-server --port 6969 https://example.com/mcp
+`);
+  process.exit(values.help ? 0 : 1);
+}
+
+const remoteUrl = positionals[0];
+const port = parseInt(values.port, 10);
+
+createProxy({ remoteUrl, port });

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@diegoaltoworks/localize-remote-mcp-server",
+  "version": "1.0.0",
+  "description": "Proxy a remote HTTP MCP server to localhost",
+  "bin": {
+    "localize-remote-mcp-server": "./bin/cli.js"
+  },
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "keywords": [
+    "mcp",
+    "proxy",
+    "model-context-protocol"
+  ]
+}

package/src/proxy.js

@@ -0,0 +1,84 @@
+import { createServer } from "node:http";
+
+export function createProxy({ remoteUrl, port }) {
+  const remote = new URL(remoteUrl);
+  const localPath = remote.pathname;
+
+  const server = createServer(async (req, res) => {
+    // Only proxy requests to the MCP path
+    if (req.url !== localPath) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end(`Not found. MCP endpoint is at ${localPath}\n`);
+      return;
+    }
+
+    // MCP Streamable HTTP uses POST and GET
+    if (req.method !== "POST" && req.method !== "GET") {
+      res.writeHead(405, { "content-type": "text/plain" });
+      res.end("Method not allowed.\n");
+      return;
+    }
+
+    try {
+      const body = req.method === "POST" ? await readBody(req) : undefined;
+
+      // Forward all relevant headers
+      const headers = {};
+      if (req.headers["content-type"]) {
+        headers["content-type"] = req.headers["content-type"];
+      }
+      // MCP Streamable HTTP requires accepting both JSON and SSE
+      headers["accept"] =
+        req.headers["accept"] || "application/json, text/event-stream";
+      if (req.headers["authorization"]) {
+        headers["authorization"] = req.headers["authorization"];
+      }
+      if (req.headers["mcp-session-id"]) {
+        headers["mcp-session-id"] = req.headers["mcp-session-id"];
+      }
+
+      const response = await fetch(remoteUrl, {
+        method: req.method,
+        headers,
+        body,
+      });
+
+      // Forward status and headers back
+      const responseHeaders = {};
+      for (const [key, value] of response.headers) {
+        responseHeaders[key] = value;
+      }
+      res.writeHead(response.status, responseHeaders);
+
+      // Stream the response body back
+      if (response.body) {
+        const reader = response.body.getReader();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(value);
+        }
+      }
+      res.end();
+    } catch (err) {
+      console.error("Proxy error:", err.message);
+      res.writeHead(502, { "content-type": "text/plain" });
+      res.end(`Bad gateway: ${err.message}\n`);
+    }
+  });
+
+  server.listen(port, () => {
+    console.log(`Proxying ${remoteUrl} → http://localhost:${port}${localPath}`);
+  });
+
+  return server;
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}