@bahulam/code 2.6.0

package/src/mcp/transport-shttp.mjs

@@ -0,0 +1,130 @@
+/**
+ * Streamable HTTP Transport — new MCP transport.
+ *
+ * Uses POST with SSE response body for bidirectional communication.
+ * Each request is a POST that returns a streaming SSE response.
+ */
+
+export class StreamableHttpTransport {
+    /**
+     * @param {string} url - HTTP endpoint URL
+     * @param {object} [options] - { headers, timeout, sessionId }
+     */
+    constructor(url, options = {}) {
+        this.url = url;
+        this.headers = options.headers || {};
+        this.timeout = options.timeout || 30000;
+        this.sessionId = options.sessionId || null;
+        this.connected = false;
+    }
+
+    async connect() {
+        // Test connectivity with an empty request
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'text/event-stream',
+                ...this.headers,
+            },
+            body: JSON.stringify({ jsonrpc: '2.0', method: 'ping', params: {} }),
+        });
+
+        if (res.ok) {
+            this.sessionId = res.headers.get('x-session-id') || this.sessionId;
+            this.connected = true;
+        }
+        return this;
+    }
+
+    /**
+     * Send a JSON-RPC request and receive a streaming SSE response.
+     * Collects all events and returns the final result.
+     */
+    async request(method, params) {
+        const id = Date.now();
+        const body = { jsonrpc: '2.0', id, method, params };
+
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+            ...this.headers,
+        };
+
+        if (this.sessionId) {
+            headers['x-session-id'] = this.sessionId;
+        }
+
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+
+        if (!res.ok) {
+            throw new Error(`sHTTP error: ${res.status} ${res.statusText}`);
+        }
+
+        const contentType = res.headers.get('content-type') || '';
+
+        // If SSE response, stream it
+        if (contentType.includes('text/event-stream')) {
+            return this._readSSEResponse(res);
+        }
+
+        // Otherwise, plain JSON
+        return res.json();
+    }
+
+    async _readSSEResponse(res) {
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let result = null;
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split('\n\n');
+                buffer = events.pop() || '';
+
+                for (const raw of events) {
+                    const parsed = this._parseEvent(raw);
+                    if (parsed?.data?.result !== undefined) {
+                        result = parsed.data.result;
+                    } else if (parsed?.data?.error) {
+                        throw new Error(parsed.data.error.message || 'Unknown error');
+                    }
+                }
+            }
+        } finally {
+            reader.releaseLock();
+        }
+
+        return result;
+    }
+
+    _parseEvent(raw) {
+        const dataLines = [];
+        for (const line of raw.split('\n')) {
+            if (line.startsWith('data: ')) dataLines.push(line.slice(6));
+        }
+        if (dataLines.length === 0) return null;
+        try {
+            return { data: JSON.parse(dataLines.join('\n')) };
+        } catch {
+            return null;
+        }
+    }
+
+    async send(message) {
+        return this.request(message.method, message.params);
+    }
+
+    async disconnect() {
+        this.connected = false;
+    }
+}

package/src/mcp/transport-sse.mjs

@@ -0,0 +1,131 @@
+/**
+ * SSE Transport — Server-Sent Events transport for MCP.
+ *
+ * Connects to an MCP server over HTTP using SSE for server-to-client
+ * messages and POST for client-to-server messages.
+ */
+
+export class SseTransport {
+    /**
+     * @param {string} url - SSE endpoint URL
+     * @param {object} [options] - { headers, timeout }
+     */
+    constructor(url, options = {}) {
+        this.url = url;
+        this.headers = options.headers || {};
+        this.timeout = options.timeout || 30000;
+        this.connected = false;
+        this.messageHandlers = [];
+        this.reader = null;
+        this.abortController = null;
+    }
+
+    async connect() {
+        this.abortController = new AbortController();
+
+        const res = await fetch(this.url, {
+            headers: {
+                Accept: 'text/event-stream',
+                ...this.headers,
+            },
+            signal: this.abortController.signal,
+        });
+
+        if (!res.ok) {
+            throw new Error(`SSE connect failed: HTTP ${res.status}`);
+        }
+
+        this.connected = true;
+        this.reader = res.body.getReader();
+        this._readLoop();
+        return this;
+    }
+
+    async _readLoop() {
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        try {
+            while (this.connected) {
+                const { done, value } = await this.reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+                const events = buffer.split('\n\n');
+                buffer = events.pop() || '';
+
+                for (const raw of events) {
+                    const parsed = this._parseSSE(raw);
+                    if (parsed) {
+                        for (const handler of this.messageHandlers) {
+                            handler(parsed);
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            if (err.name !== 'AbortError') {
+                this._handleError(err);
+            }
+        }
+    }
+
+    _parseSSE(raw) {
+        let eventType = 'message';
+        const dataLines = [];
+
+        for (const line of raw.split('\n')) {
+            if (line.startsWith('event: ')) eventType = line.slice(7).trim();
+            else if (line.startsWith('data: ')) dataLines.push(line.slice(6));
+        }
+
+        if (dataLines.length === 0) return null;
+
+        try {
+            return {
+                type: eventType,
+                data: JSON.parse(dataLines.join('\n')),
+            };
+        } catch {
+            return { type: eventType, data: dataLines.join('\n') };
+        }
+    }
+
+    async send(message) {
+        const res = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers,
+            },
+            body: JSON.stringify(message),
+        });
+
+        if (!res.ok) {
+            throw new Error(`SSE send failed: HTTP ${res.status}`);
+        }
+
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        } catch {
+            return text;
+        }
+    }
+
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+
+    _handleError(err) {
+        if (process.env.MCP_DEBUG) {
+            console.error(`[SSE transport] Error: ${err.message}`);
+        }
+    }
+
+    async disconnect() {
+        this.connected = false;
+        this.abortController?.abort();
+        this.reader = null;
+    }
+}

package/src/mcp/transport-ws.mjs

@@ -0,0 +1,134 @@
+/**
+ * WebSocket Transport — bidirectional MCP transport over WebSocket.
+ *
+ * Uses the ws protocol for full-duplex communication with MCP servers.
+ * Falls back to a stub if WebSocket is not available in the runtime.
+ */
+
+export class WebSocketTransport {
+    /**
+     * @param {string} url - WebSocket URL (ws:// or wss://)
+     * @param {object} [options] - { headers, timeout, protocols }
+     */
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = options;
+        this.timeout = options.timeout || 30000;
+        this.ws = null;
+        this.connected = false;
+        this.requestId = 0;
+        this.pending = new Map();
+        this.messageHandlers = [];
+    }
+
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                // Use global WebSocket if available (Node 22+)
+                const WS = globalThis.WebSocket;
+                if (!WS) {
+                    throw new Error('WebSocket not available in this runtime');
+                }
+
+                this.ws = new WS(this.url, this.options.protocols);
+
+                const timeout = setTimeout(() => {
+                    reject(new Error('WebSocket connection timeout'));
+                }, this.timeout);
+
+                this.ws.onopen = () => {
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    resolve(this);
+                };
+
+                this.ws.onmessage = (event) => {
+                    this._handleMessage(event.data);
+                };
+
+                this.ws.onerror = (err) => {
+                    clearTimeout(timeout);
+                    reject(new Error(`WebSocket error: ${err.message || 'unknown'}`));
+                };
+
+                this.ws.onclose = () => {
+                    this.connected = false;
+                    for (const [, { reject: rej }] of this.pending) {
+                        rej(new Error('WebSocket closed'));
+                    }
+                    this.pending.clear();
+                };
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    _handleMessage(data) {
+        try {
+            const msg = JSON.parse(typeof data === 'string' ? data : data.toString());
+
+            // Handle response to pending request
+            if (msg.id && this.pending.has(msg.id)) {
+                const { resolve, reject } = this.pending.get(msg.id);
+                this.pending.delete(msg.id);
+                if (msg.error) {
+                    reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+                } else {
+                    resolve(msg.result);
+                }
+                return;
+            }
+
+            // Handle notifications
+            for (const handler of this.messageHandlers) {
+                handler(msg);
+            }
+        } catch {
+            // Malformed message
+        }
+    }
+
+    async request(method, params) {
+        if (!this.connected) throw new Error('WebSocket not connected');
+
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`WebSocket request timeout: ${method}`));
+            }, this.timeout);
+
+            const origResolve = resolve;
+            this.pending.set(id, {
+                resolve: (val) => { clearTimeout(timeout); origResolve(val); },
+                reject: (err) => { clearTimeout(timeout); reject(err); },
+            });
+
+            this.ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params: params || {},
+            }));
+        });
+    }
+
+    async send(message) {
+        return this.request(message.method, message.params);
+    }
+
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+
+    async disconnect() {
+        this.connected = false;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}