@aiwerk/mcp-bridge 1.0.0 → 1.0.2

package/dist/src/transport-sse.js

@@ -0,0 +1,207 @@
+import { nextRequestId } from "./types.js";
+import { BaseTransport, resolveEnvRecord, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+export class SseTransport extends BaseTransport {
+    endpointUrl = null;
+    sseAbortController = null;
+    currentDataBuffer = [];
+    get transportName() { return "SSE"; }
+    async connect() {
+        if (!this.config.url) {
+            throw new Error("SSE transport requires URL");
+        }
+        warnIfNonTlsRemoteUrl(this.config.url, this.logger);
+        // Validate that all header env vars resolve (fail fast)
+        resolveEnvRecord(this.config.headers || {}, "header");
+        this.sseAbortController = new AbortController();
+        const connectionTimeout = this.clientConfig.connectionTimeoutMs || 10000;
+        const streamReady = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("SSE endpoint URL not received within timeout")), connectionTimeout);
+            this._onEndpointReceived = () => { clearTimeout(timer); resolve(); };
+        });
+        // Fire and forget the stream reader
+        this.startEventStream().catch((error) => {
+            if (error instanceof Error && error.name !== 'AbortError') {
+                this.logger.error("[mcp-bridge] SSE stream error:", error.message);
+                this.scheduleReconnect();
+            }
+        });
+        await streamReady;
+        this.connected = true;
+        this.backoffDelay = this.clientConfig.reconnectIntervalMs || 30000;
+    }
+    _onEndpointReceived = null;
+    async startEventStream() {
+        if (!this.config.url)
+            return;
+        const headers = resolveEnvRecord({
+            ...this.config.headers,
+            "Accept": "text/event-stream"
+        }, "header");
+        try {
+            const response = await fetch(this.config.url, {
+                method: "GET",
+                headers,
+                signal: this.sseAbortController?.signal
+            });
+            if (!response.ok) {
+                throw new Error(`SSE connection failed: HTTP ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error("No response body for SSE stream");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let currentEvent = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith("event: ")) {
+                        currentEvent = trimmed.substring(7).trim();
+                    }
+                    else if (trimmed === "") {
+                        this.processEventLine(line, currentEvent);
+                        currentEvent = "";
+                    }
+                    else {
+                        this.processEventLine(line, currentEvent);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError')
+                return;
+            this.logger.error("SSE stream error:", error);
+            this.scheduleReconnect();
+        }
+    }
+    processEventLine(line, currentEvent = "") {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("event: "))
+            return;
+        if (trimmed.startsWith("data: ")) {
+            this.currentDataBuffer.push(trimmed.substring(6));
+            return;
+        }
+        if (trimmed === "") {
+            if (this.currentDataBuffer.length === 0)
+                return;
+            const data = this.currentDataBuffer.join("\n");
+            this.currentDataBuffer = [];
+            if (currentEvent === "endpoint") {
+                if (data.startsWith("/")) {
+                    const base = new URL(this.config.url);
+                    this.endpointUrl = `${base.origin}${data}`;
+                }
+                else if (data.startsWith("http")) {
+                    if (!this.isSameOrigin(data)) {
+                        this.logger.warn(`[mcp-bridge] Rejected SSE endpoint with mismatched origin: ${data}`);
+                        return;
+                    }
+                    this.endpointUrl = data;
+                }
+                else {
+                    this.logger.warn(`[mcp-bridge] Rejected SSE endpoint with unsupported URL format: ${data}`);
+                    return;
+                }
+                this.logger.info(`[mcp-bridge] SSE endpoint URL received: ${this.endpointUrl}`);
+                if (this._onEndpointReceived) {
+                    this._onEndpointReceived();
+                    this._onEndpointReceived = null;
+                }
+                return;
+            }
+            try {
+                const message = JSON.parse(data);
+                this.handleMessage(message);
+            }
+            catch {
+                this.logger.debug("Failed to parse SSE data as JSON:", data);
+            }
+        }
+    }
+    async sendNotification(notification) {
+        if (!this.connected || !this.endpointUrl) {
+            throw new Error("SSE transport not connected or no endpoint URL");
+        }
+        const headers = resolveEnvRecord({
+            ...this.config.headers,
+            "Content-Type": "application/json"
+        }, "header");
+        const response = await fetch(this.endpointUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(notification)
+        });
+        if (!response.ok) {
+            this.logger.warn(`[mcp-bridge] SSE notification got HTTP ${response.status}`);
+        }
+    }
+    async sendRequest(request) {
+        if (!this.connected || !this.endpointUrl) {
+            throw new Error("SSE transport not connected or no endpoint URL");
+        }
+        const id = nextRequestId();
+        const requestWithId = { ...request, id };
+        return new Promise((resolve, reject) => {
+            const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout after ${requestTimeout}ms`));
+            }, requestTimeout);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            const headers = resolveEnvRecord({
+                ...this.config.headers,
+                "Content-Type": "application/json"
+            }, "header");
+            // The response arrives via the SSE stream (handleMessage), not from this fetch.
+            // The fetch only confirms the server accepted the request (HTTP 200).
+            // If the fetch fails, we reject immediately; otherwise we wait for the SSE stream.
+            fetch(this.endpointUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(requestWithId)
+            })
+                .then((response) => {
+                if (!response.ok) {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`HTTP ${response.status}`));
+                }
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                this.pendingRequests.delete(id);
+                reject(error);
+            });
+        });
+    }
+    isSameOrigin(url) {
+        try {
+            if (!this.config.url)
+                return false;
+            const incoming = new URL(url);
+            const base = new URL(this.config.url);
+            return incoming.origin === base.origin;
+        }
+        catch {
+            return false;
+        }
+    }
+    async disconnect() {
+        this.connected = false;
+        this.cleanupReconnectTimer();
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = null;
+        }
+        this.rejectAllPending("Connection closed");
+    }
+}

package/dist/src/transport-stdio.d.ts

@@ -0,0 +1,20 @@
+import { McpRequest, McpResponse } from "./types.js";
+import { BaseTransport } from "./transport-base.js";
+export declare class StdioTransport extends BaseTransport {
+    private process;
+    private framingMode;
+    private stdoutBuffer;
+    private isShuttingDown;
+    protected get transportName(): string;
+    connect(): Promise<void>;
+    private startProcess;
+    private writeMessage;
+    sendNotification(notification: any): Promise<void>;
+    sendRequest(request: McpRequest): Promise<McpResponse>;
+    private processStdoutBuffer;
+    private parseNewlineMessageFromBuffer;
+    private parseLspMessageFromBuffer;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    private terminateProcessGracefully;
+}

package/dist/src/transport-stdio.js

@@ -0,0 +1,281 @@
+import { spawn } from "child_process";
+import { nextRequestId } from "./types.js";
+import { BaseTransport, resolveEnvRecord, resolveArgs } from "./transport-base.js";
+export class StdioTransport extends BaseTransport {
+    process = null;
+    framingMode = "auto";
+    stdoutBuffer = Buffer.alloc(0);
+    isShuttingDown = false;
+    get transportName() { return "stdio"; }
+    async connect() {
+        if (!this.config.command) {
+            throw new Error("Stdio transport requires command");
+        }
+        try {
+            this.isShuttingDown = false;
+            await this.startProcess();
+            this.connected = true;
+            this.backoffDelay = this.clientConfig.reconnectIntervalMs || 30000;
+        }
+        catch (error) {
+            this.logger.error("Stdio transport connection failed:", error);
+            throw error;
+        }
+    }
+    async startProcess() {
+        if (!this.config.command)
+            return;
+        const env = { ...process.env, ...resolveEnvRecord(this.config.env || {}, "env key") };
+        const args = resolveArgs(this.config.args || [], env);
+        this.process = spawn(this.config.command, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+            env
+        });
+        if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
+            throw new Error("Failed to create process pipes");
+        }
+        this.framingMode = this.config.framing || "auto";
+        this.stdoutBuffer = Buffer.alloc(0);
+        this.process.stdout.on("data", (data) => {
+            this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, data]);
+            // Safety limit: prevent unbounded buffer growth from misbehaving servers
+            const MAX_BUFFER = 50 * 1024 * 1024; // 50MB
+            if (this.stdoutBuffer.length > MAX_BUFFER) {
+                this.logger.error(`[mcp-bridge] Stdio buffer exceeded ${MAX_BUFFER} bytes, killing process`);
+                this.process?.kill();
+                return;
+            }
+            this.processStdoutBuffer();
+        });
+        this.process.stderr.on("data", (data) => {
+            this.logger.debug(`MCP server stderr: ${data.toString()}`);
+        });
+        this.process.on("exit", (code, signal) => {
+            this.logger.debug(`MCP server process exited: code=${code}, signal=${signal}`);
+            this.connected = false;
+            this.process = null;
+            this.rejectAllPending("Process exited");
+            if (!this.isShuttingDown) {
+                this.scheduleReconnect();
+            }
+        });
+        this.process.on("error", (error) => {
+            this.logger.error("MCP server process error:", error);
+            this.connected = false;
+            this.process = null;
+            this.rejectAllPending("Process error");
+            if (!this.isShuttingDown) {
+                this.scheduleReconnect();
+            }
+        });
+        const connectionTimeout = this.clientConfig.connectionTimeoutMs || 5000;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let timeout;
+            const cleanup = () => {
+                this.process?.stdout?.off("data", onFirstData);
+                this.process?.off("error", onProcessError);
+                this.process?.off("exit", onProcessExit);
+                clearTimeout(timeout);
+            };
+            const settleResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve();
+            };
+            const settleReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const onFirstData = () => settleResolve();
+            const onProcessError = (error) => settleReject(error);
+            const onProcessExit = () => settleReject(new Error("MCP server exited before stdout became ready"));
+            this.process.stdout.once("data", onFirstData);
+            this.process.once("error", onProcessError);
+            this.process.once("exit", onProcessExit);
+            timeout = setTimeout(() => {
+                this.logger.warn(`[mcp-bridge] Stdio startup stdout readiness timed out after ${connectionTimeout}ms; continuing`);
+                settleResolve();
+            }, connectionTimeout);
+        });
+    }
+    writeMessage(message) {
+        const json = JSON.stringify(message);
+        if (this.framingMode === "lsp") {
+            const body = Buffer.from(json, "utf8");
+            this.process.stdin.write(`Content-Length: ${body.length}\r\n\r\n`);
+            this.process.stdin.write(body);
+        }
+        else {
+            this.process.stdin.write(json + '\n');
+        }
+    }
+    async sendNotification(notification) {
+        if (!this.connected || !this.process?.stdin) {
+            throw new Error("Stdio transport not connected");
+        }
+        this.writeMessage(notification);
+    }
+    async sendRequest(request) {
+        if (!this.connected || !this.process?.stdin) {
+            throw new Error("Stdio transport not connected");
+        }
+        const id = nextRequestId();
+        const requestWithId = { ...request, id };
+        return new Promise((resolve, reject) => {
+            const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout after ${requestTimeout}ms`));
+            }, requestTimeout);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            try {
+                this.writeMessage(requestWithId);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                this.pendingRequests.delete(id);
+                reject(error);
+            }
+        });
+    }
+    processStdoutBuffer() {
+        while (true) {
+            if (this.framingMode === "auto") {
+                const bufferText = this.stdoutBuffer.toString("utf8");
+                if (bufferText.includes("Content-Length:")) {
+                    this.framingMode = "lsp";
+                }
+                else if (this.stdoutBuffer.includes(0x0a)) {
+                    this.framingMode = "newline";
+                }
+                else {
+                    return;
+                }
+            }
+            if (this.framingMode === "lsp") {
+                if (!this.parseLspMessageFromBuffer())
+                    return;
+                continue;
+            }
+            if (!this.parseNewlineMessageFromBuffer())
+                return;
+        }
+    }
+    parseNewlineMessageFromBuffer() {
+        const newlineIndex = this.stdoutBuffer.indexOf(0x0a);
+        if (newlineIndex === -1)
+            return false;
+        const lineBuffer = this.stdoutBuffer.subarray(0, newlineIndex);
+        this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
+        const line = lineBuffer.toString("utf8").trim();
+        if (!line)
+            return true;
+        try {
+            const message = JSON.parse(line);
+            this.handleMessage(message);
+        }
+        catch {
+            this.logger.debug("Failed to parse stdout JSON:", line);
+        }
+        return true;
+    }
+    parseLspMessageFromBuffer() {
+        const separator = Buffer.from("\r\n\r\n");
+        let headerEndIndex = this.stdoutBuffer.indexOf(separator);
+        let headerLength = separator.length;
+        if (headerEndIndex === -1) {
+            const altSeparator = Buffer.from("\n\n");
+            headerEndIndex = this.stdoutBuffer.indexOf(altSeparator);
+            headerLength = altSeparator.length;
+        }
+        if (headerEndIndex === -1)
+            return false;
+        const headerText = this.stdoutBuffer.subarray(0, headerEndIndex).toString("utf8");
+        const contentLengthMatch = headerText.match(/Content-Length:\s*(\d+)/i);
+        if (!contentLengthMatch) {
+            this.logger.warn("[mcp-bridge] Missing Content-Length in LSP-framed stdout message; dropping malformed frame");
+            this.stdoutBuffer = this.stdoutBuffer.subarray(headerEndIndex + headerLength);
+            return true;
+        }
+        const contentLength = Number.parseInt(contentLengthMatch[1], 10);
+        const bodyStart = headerEndIndex + headerLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (this.stdoutBuffer.length < bodyEnd)
+            return false;
+        const body = this.stdoutBuffer.subarray(bodyStart, bodyEnd).toString("utf8");
+        this.stdoutBuffer = this.stdoutBuffer.subarray(bodyEnd);
+        try {
+            const message = JSON.parse(body);
+            this.handleMessage(message);
+        }
+        catch {
+            this.logger.debug("Failed to parse LSP stdout JSON:", body);
+        }
+        return true;
+    }
+    async disconnect() {
+        this.isShuttingDown = true;
+        this.connected = false;
+        this.cleanupReconnectTimer();
+        const activeProcess = this.process;
+        if (activeProcess) {
+            if (activeProcess.stdin && !activeProcess.stdin.destroyed) {
+                try {
+                    this.writeMessage({ jsonrpc: "2.0", method: "close" });
+                }
+                catch {
+                    this.logger.debug("[mcp-bridge] Failed to send close notification during stdio disconnect");
+                }
+            }
+            await this.terminateProcessGracefully(activeProcess);
+            if (this.process === activeProcess) {
+                this.process = null;
+            }
+        }
+        this.rejectAllPending("Connection closed");
+    }
+    isConnected() {
+        return this.connected && this.process !== null;
+    }
+    async terminateProcessGracefully(proc) {
+        if (proc.exitCode !== null || proc.killed)
+            return;
+        await new Promise((resolve) => {
+            let done = false;
+            let forceKillTimer = null;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                if (forceKillTimer)
+                    clearTimeout(forceKillTimer);
+                proc.off("exit", onExit);
+                resolve();
+            };
+            const onExit = () => finish();
+            proc.once("exit", onExit);
+            try {
+                proc.kill("SIGINT");
+            }
+            catch {
+                finish();
+                return;
+            }
+            forceKillTimer = setTimeout(() => {
+                if (proc.exitCode === null && !proc.killed) {
+                    try {
+                        proc.kill("SIGTERM");
+                    }
+                    catch { /* ignore */ }
+                }
+                setTimeout(finish, 200);
+            }, 2000);
+        });
+    }
+}

package/dist/src/transport-streamable-http.d.ts

@@ -0,0 +1,11 @@
+import { McpRequest, McpResponse } from "./types.js";
+import { BaseTransport } from "./transport-base.js";
+export declare class StreamableHttpTransport extends BaseTransport {
+    private sessionId?;
+    protected get transportName(): string;
+    connect(): Promise<void>;
+    sendRequest(request: McpRequest): Promise<McpResponse>;
+    sendNotification(notification: any): Promise<void>;
+    private probeServer;
+    disconnect(): Promise<void>;
+}

package/dist/src/transport-streamable-http.js

@@ -0,0 +1,164 @@
+import { nextRequestId } from "./types.js";
+import { BaseTransport, resolveEnvRecord, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+export class StreamableHttpTransport extends BaseTransport {
+    sessionId;
+    get transportName() { return "streamable-http"; }
+    async connect() {
+        if (!this.config.url) {
+            throw new Error("Streamable HTTP transport requires URL");
+        }
+        warnIfNonTlsRemoteUrl(this.config.url, this.logger);
+        // Validate that all header env vars resolve (fail fast)
+        resolveEnvRecord(this.config.headers || {}, "header");
+        await this.probeServer();
+        this.connected = true;
+        this.backoffDelay = this.clientConfig.reconnectIntervalMs || 30000;
+        this.logger.info(`[mcp-bridge] Streamable HTTP transport ready for ${this.config.url}`);
+    }
+    async sendRequest(request) {
+        if (!this.connected || !this.config.url) {
+            throw new Error("Streamable HTTP transport not connected");
+        }
+        const id = nextRequestId();
+        const requestWithId = { ...request, id };
+        return new Promise((resolve, reject) => {
+            const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout after ${requestTimeout}ms`));
+            }, requestTimeout);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            const headers = resolveEnvRecord({
+                "Accept": "application/json, text/event-stream",
+                ...this.config.headers,
+                "Content-Type": "application/json"
+            }, "header");
+            if (this.sessionId) {
+                headers["mcp-session-id"] = this.sessionId;
+            }
+            fetch(this.config.url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(requestWithId)
+            })
+                .then(async (response) => {
+                const responseSessionId = response.headers.get("mcp-session-id");
+                if (responseSessionId) {
+                    this.sessionId = responseSessionId;
+                }
+                if (!response.ok) {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
+                    return;
+                }
+                try {
+                    const contentType = response.headers.get("content-type") || "";
+                    let jsonResponse;
+                    if (contentType.includes("text/event-stream")) {
+                        const text = await response.text();
+                        const dataLines = text.split('\n')
+                            .filter((line) => line.startsWith('data:'))
+                            .map((line) => line.substring(5).trim());
+                        if (dataLines.length > 0) {
+                            jsonResponse = JSON.parse(dataLines[dataLines.length - 1]);
+                        }
+                        else {
+                            throw new Error("No data lines in SSE response");
+                        }
+                    }
+                    else {
+                        jsonResponse = await response.json();
+                    }
+                    this.handleMessage(jsonResponse);
+                }
+                catch (error) {
+                    clearTimeout(timeout);
+                    this.pendingRequests.delete(id);
+                    reject(new Error("Failed to parse response: " + (error instanceof Error ? error.message : String(error))));
+                }
+            })
+                .catch(error => {
+                clearTimeout(timeout);
+                this.pendingRequests.delete(id);
+                if (error.name === 'TypeError' && error.message.includes('fetch')) {
+                    this.logger.error("Connection error, scheduling reconnect:", error.message);
+                    this.scheduleReconnect();
+                }
+                reject(error);
+            });
+        });
+    }
+    async sendNotification(notification) {
+        if (!this.connected || !this.config.url) {
+            throw new Error("Streamable HTTP transport not connected");
+        }
+        const headers = resolveEnvRecord({
+            "Accept": "application/json, text/event-stream",
+            ...this.config.headers,
+            "Content-Type": "application/json"
+        }, "header");
+        if (this.sessionId) {
+            headers["mcp-session-id"] = this.sessionId;
+        }
+        try {
+            const response = await fetch(this.config.url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(notification)
+            });
+            const responseSessionId = response.headers.get("mcp-session-id");
+            if (responseSessionId) {
+                this.sessionId = responseSessionId;
+            }
+            if (!response.ok && response.status >= 500) {
+                throw new Error(`Server error: HTTP ${response.status}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'TypeError' && error.message.includes('fetch')) {
+                this.logger.error("Connection error during notification, scheduling reconnect:", error.message);
+                this.scheduleReconnect();
+            }
+            throw error;
+        }
+    }
+    async probeServer() {
+        if (!this.config.url)
+            return;
+        try {
+            const optionsResponse = await fetch(this.config.url, { method: "OPTIONS" });
+            if (optionsResponse.ok)
+                return;
+            const headers = resolveEnvRecord(this.config.headers || {}, "header");
+            const headResponse = await fetch(this.config.url, { method: "HEAD", headers });
+            if (!headResponse.ok) {
+                this.logger.warn(`[mcp-bridge] Streamable HTTP server probe: OPTIONS ${optionsResponse.status}, HEAD ${headResponse.status} (non-blocking, connection continues)`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`[mcp-bridge] Streamable HTTP server probe failed (non-blocking): ${error?.message || error}`);
+        }
+    }
+    async disconnect() {
+        this.connected = false;
+        this.cleanupReconnectTimer();
+        // Send DELETE request if we have a session to clean up
+        if (this.sessionId && this.config.url) {
+            try {
+                const headers = resolveEnvRecord(this.config.headers || {}, "header");
+                headers["mcp-session-id"] = this.sessionId;
+                await fetch(this.config.url, {
+                    method: "DELETE",
+                    headers
+                });
+                this.sessionId = undefined;
+                this.logger.info("Streamable HTTP session cleaned up");
+            }
+            catch (error) {
+                this.logger.warn("Failed to clean up session on disconnect:", error);
+            }
+        }
+        this.rejectAllPending("Connection closed");
+    }
+}