@silver886/mcp-proxy 0.1.3 → 0.2.0

package/dist/proxy/runtime/sse.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseReader = void 0;
+const eventsource_parser_1 = require("eventsource-parser");
+const constants_js_1 = require("../core/constants.js");
+const uri_js_1 = require("../routing/uri.js");
+function sleepCancellable(ms, signal) {
+    return new Promise((resolveP) => {
+        if (signal.aborted)
+            return resolveP();
+        const timer = setTimeout(resolveP, ms);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolveP();
+        }, { once: true });
+    });
+}
+class SseReader {
+    cb;
+    constructor(cb) {
+        this.cb = cb;
+    }
+    // Owner-side entry: ensure exactly one loop is active per (host, server)
+    // session id. Aborting the previous controller torpedoes a stale loop
+    // before its retry chain reconnects to a session id that's been rotated.
+    start(host, name, sessionId) {
+        const prev = host.sseControllers.get(name);
+        if (prev)
+            prev.abort();
+        const ctrl = new AbortController();
+        host.sseControllers.set(name, ctrl);
+        void this.loop(host, name, sessionId, ctrl).finally(() => {
+            if (host.sseControllers.get(name) === ctrl)
+                host.sseControllers.delete(name);
+        });
+    }
+    async loop(host, name, sessionId, ctrl) {
+        let backoff = constants_js_1.SSE_BACKOFF_INITIAL_MS;
+        while (!ctrl.signal.aborted) {
+            if (!this.cb.isCurrent(host, name, sessionId))
+                return;
+            const url = `${host.config.tunnelUrl}/servers/${name}`;
+            // Connect-phase abort wiring: a separate inner controller fires when
+            // EITHER the lifecycle signal aborts OR the connect budget elapses.
+            // We can't pass `AbortSignal.any([ctrl.signal, AbortSignal.timeout(N)])`
+            // straight to fetch(), because the same signal is then attached to
+            // the response body — meaning a 15 s timeout would also kill a
+            // healthy long-lived stream after 15 s. Instead we tear down the
+            // timer / lifecycle relay the moment fetch() resolves, leaving the
+            // body cancellation path in consume() to use ctrl.signal directly.
+            const connectCtrl = new AbortController();
+            const lifecycleRelay = () => connectCtrl.abort();
+            ctrl.signal.addEventListener("abort", lifecycleRelay, { once: true });
+            const connectTimer = setTimeout(() => connectCtrl.abort(), constants_js_1.SSE_CONNECT_TIMEOUT_MS);
+            try {
+                const resp = await fetch(url, {
+                    method: "GET",
+                    headers: {
+                        Accept: "text/event-stream",
+                        Authorization: `Bearer ${host.config.authToken}`,
+                        "Mcp-Session-Id": sessionId,
+                    },
+                    signal: connectCtrl.signal,
+                });
+                clearTimeout(connectTimer);
+                ctrl.signal.removeEventListener("abort", lifecycleRelay);
+                if (resp.ok && resp.body) {
+                    backoff = constants_js_1.SSE_BACKOFF_INITIAL_MS;
+                    await this.consume(host, name, resp.body, ctrl.signal);
+                }
+                else if (resp.status === 401 || resp.status === 404) {
+                    // Auth changed or session vanished — no point retrying this loop.
+                    // The next upstream POST will rotate the session id and start a
+                    // fresh loop via the orchestrator's captureSessionId.
+                    return;
+                }
+            }
+            catch {
+                if (ctrl.signal.aborted)
+                    return;
+                // Transient — fall through to backoff.
+            }
+            finally {
+                clearTimeout(connectTimer);
+                ctrl.signal.removeEventListener("abort", lifecycleRelay);
+            }
+            if (ctrl.signal.aborted)
+                return;
+            await sleepCancellable(backoff, ctrl.signal);
+            backoff = Math.min(backoff * 2, constants_js_1.SSE_BACKOFF_MAX_MS);
+        }
+    }
+    async consume(host, name, body, signal) {
+        const reader = body.getReader();
+        const onAbort = () => { reader.cancel().catch(() => { }); };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const decoder = new TextDecoder();
+        // Hand the byte→event split to eventsource-parser. It correctly handles
+        // CRLF, BOM, retry: directives, comment lines, and event types — none
+        // of which we'd otherwise be reasoning about ourselves. Our only job
+        // here is to JSON-parse `data` and dispatch.
+        const parser = (0, eventsource_parser_1.createParser)({
+            onEvent: (evt) => this.dispatchData(host, name, evt.data),
+        });
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                parser.feed(decoder.decode(value, { stream: true }));
+            }
+        }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+    dispatchData(host, name, payload) {
+        let msg;
+        try {
+            msg = JSON.parse(payload);
+        }
+        catch {
+            return;
+        }
+        if (msg.jsonrpc !== "2.0")
+            return;
+        const hasMethod = typeof msg.method === "string";
+        const hasId = msg.id !== undefined && msg.id !== null;
+        // Server-initiated request: bridge to the client and let the orchestrator
+        // remember enough to route the response back to this session.
+        if (hasMethod && hasId) {
+            this.cb.onUpstreamRequest(host, name, msg);
+            return;
+        }
+        if (!hasMethod)
+            return; // stray response — not expected on this stream
+        // Notifications: list_changed events trigger a cache refresh BEFORE
+        // forwarding so the agent's follow-up list call sees fresh data.
+        // resources/updated carries the upstream's raw URI; we wrap it in the
+        // proxy's `mcp+host://` envelope so the agent sees the same namespaced
+        // URI it subscribed under. Other notifications (logging, progress,
+        // cancelled, roots/list_changed) don't carry resource URIs.
+        if (msg.method === "notifications/tools/list_changed") {
+            this.cb.onListChanged(host, name, "tools").catch(() => { })
+                .finally(() => this.cb.onNotification(msg));
+            return;
+        }
+        if (msg.method === "notifications/prompts/list_changed") {
+            this.cb.onListChanged(host, name, "prompts").catch(() => { })
+                .finally(() => this.cb.onNotification(msg));
+            return;
+        }
+        if (msg.method === "notifications/resources/list_changed") {
+            this.cb.onListChanged(host, name, "resources").catch(() => { })
+                .finally(() => this.cb.onNotification(msg));
+            return;
+        }
+        if (msg.method === "notifications/resources/updated") {
+            const params = (msg.params ?? {});
+            if (typeof params.uri === "string") {
+                const wrapped = (0, uri_js_1.wrapResourceUri)(host.config.id, name, params.uri);
+                this.cb.onNotification({ ...msg, params: { ...params, uri: wrapped } });
+                return;
+            }
+        }
+        this.cb.onNotification(msg);
+    }
+}
+exports.SseReader = SseReader;

package/dist/proxy/runtime/upstream-bridge.d.ts

@@ -0,0 +1,27 @@
+import type { HostConfig, HostState } from "../core/types.js";
+export declare class UpstreamBridge {
+    private readonly hostHeaders;
+    private readonly captureSessionId;
+    private readonly writeToAgent;
+    private requests;
+    private counter;
+    constructor(hostHeaders: (host: HostConfig) => Record<string, string>, captureSessionId: (host: HostState, serverName: string, newId: string | null) => void, writeToAgent: (line: string) => void);
+    bridge(host: HostState, serverName: string, msg: {
+        id: string | number;
+        method: string;
+        params?: unknown;
+    }): void;
+    routeResponse(hosts: Map<string, HostState>, id: string | number, msg: {
+        jsonrpc?: string;
+        id?: string | number | null;
+        result?: unknown;
+        error?: unknown;
+    }): void;
+    consumeForCancel(id: string | number): {
+        hostId: string;
+        serverName: string;
+        originalId: string | number;
+    } | null;
+    clear(hosts: Map<string, HostState>): Promise<void>;
+    private postResponse;
+}

package/dist/proxy/runtime/upstream-bridge.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpstreamBridge = void 0;
+const protocol_js_1 = require("../../shared/protocol.js");
+const constants_js_1 = require("../core/constants.js");
+const fetch_timeout_js_1 = require("../core/fetch-timeout.js");
+// Bridges server-initiated MCP requests (sampling/createMessage,
+// elicitation/create, roots/list, ping, …) from an upstream session out to
+// the agent and back. The agent sees a synthetic id (`proxy-srv-N`); the
+// upstream sees its original id. Maintaining a separate id namespace from
+// `inflight` (which covers agent→server requests) means a cancellation can
+// always identify the correct half of the bridge.
+class UpstreamBridge {
+    hostHeaders;
+    captureSessionId;
+    writeToAgent;
+    requests = new Map();
+    counter = 0;
+    constructor(hostHeaders, captureSessionId, writeToAgent) {
+        this.hostHeaders = hostHeaders;
+        this.captureSessionId = captureSessionId;
+        this.writeToAgent = writeToAgent;
+    }
+    // Register an upstream request and forward its synthetic-id form to the
+    // agent. UPSTREAM_REQUEST_TIMEOUT_MS later (default 120s) we tell the
+    // upstream we never got an answer so its child stops waiting.
+    bridge(host, serverName, msg) {
+        const server = host.servers.get(serverName);
+        if (!server || !server.sessionId)
+            return;
+        const newId = `proxy-srv-${++this.counter}`;
+        // Snapshot the originating session id. server.sessionId can rotate via
+        // captureSessionId between bridge() and the timeout firing; the timeout
+        // response must go to the session that asked, not whatever the host has
+        // most recently issued for this server.
+        const sessionId = server.sessionId;
+        const timer = setTimeout(() => {
+            this.requests.delete(newId);
+            void this.postResponse(host, serverName, sessionId, {
+                jsonrpc: "2.0",
+                id: msg.id,
+                error: { code: protocol_js_1.ErrorCode.REQUEST_TIMEOUT, message: "Client did not respond in time" },
+            });
+        }, constants_js_1.UPSTREAM_REQUEST_TIMEOUT_MS);
+        timer.unref();
+        this.requests.set(newId, {
+            hostId: host.config.id,
+            serverName,
+            sessionId,
+            originalId: msg.id,
+            timer,
+        });
+        this.writeToAgent(JSON.stringify({
+            jsonrpc: "2.0",
+            id: newId,
+            method: msg.method,
+            params: msg.params,
+        }));
+    }
+    // Agent's response arrives with our synthetic id; restore the original id
+    // and post it to the upstream session that asked.
+    routeResponse(hosts, id, msg) {
+        const ctx = this.requests.get(id);
+        if (!ctx)
+            return;
+        clearTimeout(ctx.timer);
+        this.requests.delete(id);
+        const host = hosts.get(ctx.hostId);
+        if (!host)
+            return;
+        const body = { jsonrpc: "2.0", id: ctx.originalId };
+        if (msg.error !== undefined)
+            body.error = msg.error;
+        else
+            body.result = msg.result ?? null;
+        void this.postResponse(host, ctx.serverName, ctx.sessionId, body);
+    }
+    // Used by handleClientNotification when the agent cancels a bridged
+    // request: clear our tracking, return the original id so the caller can
+    // forward `notifications/cancelled` upstream with the upstream's own id.
+    consumeForCancel(id) {
+        const ctx = this.requests.get(id);
+        if (!ctx)
+            return null;
+        clearTimeout(ctx.timer);
+        this.requests.delete(id);
+        return { hostId: ctx.hostId, serverName: ctx.serverName, originalId: ctx.originalId };
+    }
+    // Tear down on session close / re-pair. Two responsibilities:
+    //   1) cancel timers so the event loop can exit and so a stale timer
+    //      doesn't post a REQUEST_TIMEOUT response after we've already
+    //      answered with INTERNAL below;
+    //   2) proactively answer each pending upstream request with a JSON-RPC
+    //      error so the upstream child stops waiting on its own
+    //      UPSTREAM_REQUEST_TIMEOUT_MS (120s). closeAllSessions DELETEs the
+    //      session right after, but DELETE is fired-and-forgotten — without
+    //      this, a network blip on the DELETE leaves the child stalled until
+    //      its own timeout. Map is cleared first so a late routeResponse
+    //      becomes a no-op rather than a duplicate post.
+    async clear(hosts) {
+        const pending = Array.from(this.requests.values());
+        this.requests.clear();
+        for (const ctx of pending)
+            clearTimeout(ctx.timer);
+        await Promise.allSettled(pending.map((ctx) => {
+            const host = hosts.get(ctx.hostId);
+            if (!host)
+                return;
+            return this.postResponse(host, ctx.serverName, ctx.sessionId, {
+                jsonrpc: "2.0",
+                id: ctx.originalId,
+                error: { code: protocol_js_1.ErrorCode.INTERNAL, message: "proxy reconfigured before client responded" },
+            });
+        }));
+    }
+    async postResponse(host, serverName, sessionId, body) {
+        const target = `${host.config.tunnelUrl}/servers/${serverName}`;
+        const headers = { ...this.hostHeaders(host.config), "Mcp-Session-Id": sessionId };
+        try {
+            const resp = await fetch(target, {
+                method: "POST",
+                headers,
+                signal: (0, fetch_timeout_js_1.timeoutSignal)(constants_js_1.TOOL_FORWARD_TIMEOUT_MS),
+                body: JSON.stringify(body),
+            });
+            this.captureSessionId(host, serverName, resp.headers.get("mcp-session-id"));
+        }
+        catch {
+            // Upstream unreachable — server will time out on its end.
+        }
+    }
+}
+exports.UpstreamBridge = UpstreamBridge;

package/dist/proxy/server.d.ts

@@ -0,0 +1,15 @@
+import type { HostConfig, Prompt, Resource, ResourceTemplate, Tool } from "./core/types.js";
+export declare class ProxyServer {
+    private state;
+    private sse;
+    private bridge;
+    private runner;
+    private forwarder;
+    private pairing;
+    private handlers;
+    constructor();
+    start(): void;
+    private handleLine;
+}
+export declare function main(): void;
+export type { HostConfig, Prompt, Resource, ResourceTemplate, Tool };

package/dist/proxy/server.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyServer = void 0;
+exports.main = main;
+const protocol_js_1 = require("../shared/protocol.js");
+const state_js_1 = require("./core/state.js");
+const runner_js_1 = require("./discovery/runner.js");
+const controller_js_1 = require("./pairing/controller.js");
+const forwarder_js_1 = require("./runtime/forwarder.js");
+const handlers_js_1 = require("./runtime/handlers.js");
+const sse_js_1 = require("./runtime/sse.js");
+const upstream_bridge_js_1 = require("./runtime/upstream-bridge.js");
+// Composition root + JSON-RPC line router. Holds no business logic of
+// its own — just wires up the modules:
+//   ProxyState        — data the rest share
+//   SseReader         — upstream→agent notification stream
+//   UpstreamBridge    — server-initiated request bridge
+//   DiscoveryRunner   — discovery + refresh + per-server init
+//   Forwarder         — agent→server forwarding + broadcasting
+//   PairingController — pairing flow + atomic config swap
+//   RequestHandlers   — per-method JSON-RPC handlers
+// stdin-line in, stdout-line out; everything else is module composition.
+class ProxyServer {
+    state = new state_js_1.ProxyState();
+    sse;
+    bridge;
+    runner;
+    forwarder;
+    pairing;
+    handlers;
+    constructor() {
+        const writeOut = (line) => { process.stdout.write(line + "\n"); };
+        const log = (line) => { process.stderr.write(line + "\n"); };
+        const sendResult = (id, result) => {
+            writeOut(JSON.stringify({ jsonrpc: "2.0", id, result }));
+        };
+        const sendError = (code, detail, id) => {
+            writeOut((0, protocol_js_1.jsonRpcError)(code, detail, id));
+        };
+        const sendNotification = (method) => {
+            writeOut(JSON.stringify({ jsonrpc: "2.0", method }));
+        };
+        // Build the SSE/bridge pair first — they expose narrow callback
+        // interfaces that DiscoveryRunner / Forwarder need to wire into.
+        this.sse = new sse_js_1.SseReader({
+            isCurrent: (host, name, sessionId) => {
+                if (this.state.hosts.get(host.config.id) !== host)
+                    return false;
+                const server = host.servers.get(name);
+                return !!server && server.sessionId === sessionId;
+            },
+            onUpstreamRequest: (host, name, msg) => this.bridge.bridge(host, name, msg),
+            onListChanged: async (host, name, kind) => {
+                if (kind === "tools")
+                    await this.runner.refreshTools(host, name);
+                else if (kind === "prompts")
+                    await this.runner.refreshPrompts(host, name);
+                else
+                    await this.runner.refreshResources(host, name);
+            },
+            onNotification: (msg) => writeOut(JSON.stringify(msg)),
+        });
+        this.bridge = new upstream_bridge_js_1.UpstreamBridge((host) => this.state.hostHeaders(host), (host, serverName, newId) => {
+            const server = host.servers.get(serverName);
+            if (server)
+                this.runner.captureSessionId(host, serverName, server, newId);
+        }, writeOut);
+        this.runner = new runner_js_1.DiscoveryRunner(this.state, this.sse, log);
+        this.forwarder = new forwarder_js_1.Forwarder(this.state, this.runner, log, sendError, writeOut);
+        this.pairing = new controller_js_1.PairingController(this.state, this.runner, this.bridge, log, sendNotification);
+        this.handlers = new handlers_js_1.RequestHandlers(this.state, this.runner, this.forwarder, this.pairing, this.bridge, sendResult, sendError);
+    }
+    start() {
+        const stdinBuffer = new protocol_js_1.LineBuffer();
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            for (const line of stdinBuffer.push(chunk)) {
+                this.handleLine(line).catch((err) => {
+                    process.stderr.write(`Proxy error: ${err.message}\n`);
+                });
+            }
+        });
+        const shutdown = (exitCode) => {
+            this.pairing.teardownPairing();
+            this.pairing.closeAllSessions().finally(() => process.exit(exitCode));
+        };
+        process.stdin.on("end", () => shutdown(0));
+        process.on("SIGINT", () => shutdown(0));
+        process.on("SIGTERM", () => shutdown(0));
+        process.stderr.write(`Proxy ready (idle). Call the \`configure\` tool to begin pairing.\n`);
+    }
+    async handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            // Per JSON-RPC: parse failure → reply with id:null since we couldn't
+            // recover one. Silent drop here would leave the agent waiting on a
+            // request it thinks is in flight.
+            process.stdout.write((0, protocol_js_1.jsonRpcError)(protocol_js_1.ErrorCode.PARSE_ERROR, err.message, null) + "\n");
+            return;
+        }
+        const hasMethod = typeof parsed.method === "string";
+        const hasId = parsed.id !== undefined && parsed.id !== null;
+        const isResponse = !hasMethod && hasId && (parsed.result !== undefined || parsed.error !== undefined);
+        // Response from the client to a server-initiated request we previously
+        // bridged out (sampling, elicitation, roots/list, ping, …). Route it
+        // back to the upstream session that asked. Require result/error so a
+        // bare `{id:N}` falls into the invalid-request path below instead of
+        // being silently swallowed by routeResponse's unknown-id no-op.
+        if (isResponse) {
+            this.bridge.routeResponse(this.state.hosts, parsed.id, parsed);
+            return;
+        }
+        if (!hasMethod) {
+            // Neither a request (no method), a notification (no method either),
+            // nor a well-formed response (no result/error). Reply per spec so
+            // the agent doesn't hang; carry parsed.id when we have one.
+            process.stdout.write((0, protocol_js_1.jsonRpcError)(protocol_js_1.ErrorCode.INVALID_REQUEST, "missing method", parsed.id ?? null) + "\n");
+            return;
+        }
+        if (!hasId) {
+            await this.handlers.handleClientNotification(parsed.method, parsed.params ?? {});
+            return;
+        }
+        const id = parsed.id;
+        switch (parsed.method) {
+            case "initialize":
+                return this.handlers.handleInitialize(id, parsed.params);
+            case "ping":
+                // MCP `ping` is a connection-liveness no-op between two endpoints.
+                // The agent's peer here is the proxy itself, so we answer locally
+                // — there is nothing to forward and no upstream to pick when many
+                // servers are paired.
+                process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result: {} }) + "\n");
+                return;
+            case "tools/list":
+                return this.handlers.handleToolsList(id);
+            case "prompts/list":
+                return this.handlers.handlePromptsList(id);
+            case "prompts/get":
+                return this.handlers.handlePromptDispatch(id, parsed.params);
+            case "resources/list":
+                return this.handlers.handleResourcesList(id);
+            case "resources/templates/list":
+                return this.handlers.handleResourceTemplatesList(id);
+            case "resources/read":
+            case "resources/subscribe":
+            case "resources/unsubscribe":
+                return this.handlers.handleResourceMethod(id, parsed.method, parsed.params);
+            case "logging/setLevel":
+                return this.handlers.handleLoggingSetLevel(id, (parsed.params ?? {}));
+            case "completion/complete":
+                return this.handlers.handleCompletion(id, (parsed.params ?? {}));
+            case "tools/call":
+                return this.handlers.handleToolDispatch(id, parsed.params);
+            default:
+                process.stdout.write((0, protocol_js_1.jsonRpcError)(protocol_js_1.ErrorCode.METHOD_NOT_FOUND, parsed.method, id) + "\n");
+        }
+    }
+}
+exports.ProxyServer = ProxyServer;
+function main() {
+    const proxy = new ProxyServer();
+    proxy.start();
+}

package/dist/proxy.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_js_1 = require("./proxy/server.js");
+(0, server_js_1.main)();

package/{mcp/dist → dist}/shared/protocol.d.ts

@@ -1,10 +1,17 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-export { PACKAGE_NAME, PACKAGE_VERSION } from "./generated.js";
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
 export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
 export declare const DEFAULT_HOST = "127.0.0.1";
 export declare const DEFAULT_PORT = 6270;
-export declare const DEFAULT_PAGES_URL = "https://mcp-proxy.pages.dev";
+export declare const MAX_BODY_BYTES: number;
+export declare class BodyTooLargeError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
 export declare const ErrorCode: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
     readonly METHOD_NOT_FOUND: -32601;
     readonly INVALID_PARAMS: -32602;
     readonly INTERNAL: -32603;
@@ -15,6 +22,8 @@ export declare const ErrorCode: {
     readonly REQUEST_TIMEOUT: -32005;
 };
 export declare const ErrorMessage: {
+    readonly [-32700]: "Parse error";
+    readonly [-32600]: "Invalid request";
     readonly [-32601]: "Method not found";
     readonly [-32602]: "Invalid params";
     readonly [-32603]: "Internal error";
@@ -25,13 +34,16 @@ export declare const ErrorMessage: {
     readonly [-32005]: "Request timed out";
 };
 export declare function jsonRpcError(code: number, detail?: string, id?: string | number | null): string;
-export declare function readBody(req: IncomingMessage): Promise<string>;
+export declare function readBody(req: IncomingMessage, maxBytes?: number): Promise<string>;
 export declare function getArg(name: string): string | undefined;
 export declare function createServer(handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
 export declare class LineBuffer {
     private buffer;
     push(chunk: string): string[];
 }
+export declare const TOOL_NAME_SEPARATOR = "__";
+export declare const SERVER_NAME_PATTERN: RegExp;
+export declare function validateServerName(name: string): string | null;
 export interface ServerConfig {
     command: string;
     args: string[];