@oh-my-pi/pi-coding-agent 0.1.0

package/src/core/mcp/transports/http.ts

@@ -0,0 +1,316 @@
+/**
+ * MCP HTTP transport (Streamable HTTP).
+ *
+ * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
+ * Based on MCP spec 2025-03-26.
+ */
+
+import type { JsonRpcResponse, MCPHttpServerConfig, MCPSseServerConfig, MCPTransport } from "../types";
+
+/** Generate unique request ID */
+function generateId(): string {
+	return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+/** Parse SSE data line */
+function parseSSELine(line: string): { event?: string; data?: string; id?: string } | null {
+	if (line.startsWith("data:")) {
+		return { data: line.slice(5).trim() };
+	}
+	if (line.startsWith("event:")) {
+		return { event: line.slice(6).trim() };
+	}
+	if (line.startsWith("id:")) {
+		return { id: line.slice(3).trim() };
+	}
+	return null;
+}
+
+/**
+ * HTTP transport for MCP servers.
+ * Uses POST for requests, supports SSE responses.
+ */
+export class HttpTransport implements MCPTransport {
+	private _connected = false;
+	private sessionId: string | null = null;
+	private sseConnection: AbortController | null = null;
+
+	onClose?: () => void;
+	onError?: (error: Error) => void;
+	onNotification?: (method: string, params: unknown) => void;
+
+	constructor(private config: MCPHttpServerConfig | MCPSseServerConfig) {}
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	get url(): string {
+		return this.config.url;
+	}
+
+	/**
+	 * Mark transport as connected.
+	 * HTTP doesn't need persistent connection, but we track state.
+	 */
+	async connect(): Promise<void> {
+		if (this._connected) return;
+		this._connected = true;
+	}
+
+	/**
+	 * Start SSE listener for server-initiated messages.
+	 * Optional - only needed if server sends notifications.
+	 */
+	async startSSEListener(): Promise<void> {
+		if (!this._connected) return;
+		if (this.sseConnection) return;
+
+		this.sseConnection = new AbortController();
+		const headers: Record<string, string> = {
+			Accept: "text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		try {
+			const response = await fetch(this.config.url, {
+				method: "GET",
+				headers,
+				signal: this.sseConnection.signal,
+			});
+
+			if (response.status === 405) {
+				// Server doesn't support SSE listening, that's OK
+				this.sseConnection = null;
+				return;
+			}
+
+			if (!response.ok || !response.body) {
+				this.sseConnection = null;
+				return;
+			}
+
+			// Read SSE stream
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+
+			while (this._connected) {
+				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 parsed = parseSSELine(line);
+					if (parsed?.data && parsed.data !== "[DONE]") {
+						try {
+							const message = JSON.parse(parsed.data);
+							if ("method" in message && !("id" in message)) {
+								this.onNotification?.(message.method, message.params);
+							}
+						} catch {
+							// Ignore parse errors
+						}
+					}
+				}
+			}
+		} catch (error) {
+			if (error instanceof Error && error.name !== "AbortError") {
+				this.onError?.(error);
+			}
+		} finally {
+			this.sseConnection = null;
+		}
+	}
+
+	async request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T> {
+		if (!this._connected) {
+			throw new Error("Transport not connected");
+		}
+
+		const id = generateId();
+		const body = {
+			jsonrpc: "2.0" as const,
+			id,
+			method,
+			params: params ?? {},
+		};
+
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		const response = await fetch(this.config.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+		});
+
+		// Check for session ID in response
+		const newSessionId = response.headers.get("Mcp-Session-Id");
+		if (newSessionId) {
+			this.sessionId = newSessionId;
+		}
+
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`HTTP ${response.status}: ${text}`);
+		}
+
+		const contentType = response.headers.get("Content-Type") ?? "";
+
+		// Handle SSE response
+		if (contentType.includes("text/event-stream")) {
+			return this.parseSSEResponse<T>(response, id);
+		}
+
+		// Handle JSON response
+		const result = (await response.json()) as JsonRpcResponse;
+
+		if (result.error) {
+			throw new Error(`MCP error ${result.error.code}: ${result.error.message}`);
+		}
+
+		return result.result as T;
+	}
+
+	private async parseSSEResponse<T>(response: Response, expectedId: string | number): Promise<T> {
+		if (!response.body) {
+			throw new Error("No response body");
+		}
+
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let result: T | undefined;
+
+		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 parsed = parseSSELine(line);
+				if (parsed?.data && parsed.data !== "[DONE]") {
+					try {
+						const message = JSON.parse(parsed.data) as JsonRpcResponse;
+
+						// Handle our response
+						if ("id" in message && message.id === expectedId) {
+							if (message.error) {
+								throw new Error(`MCP error ${message.error.code}: ${message.error.message}`);
+							}
+							result = message.result as T;
+						}
+						// Handle notifications
+						else if ("method" in message && !("id" in message)) {
+							const notification = message as { method: string; params?: unknown };
+							this.onNotification?.(notification.method, notification.params);
+						}
+					} catch (error) {
+						if (error instanceof Error && error.message.startsWith("MCP error")) {
+							throw error;
+						}
+						// Ignore other parse errors
+					}
+				}
+			}
+		}
+
+		if (result === undefined) {
+			throw new Error("No response received");
+		}
+
+		return result;
+	}
+
+	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
+		if (!this._connected) {
+			throw new Error("Transport not connected");
+		}
+
+		const body = {
+			jsonrpc: "2.0" as const,
+			method,
+			params: params ?? {},
+		};
+
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		const response = await fetch(this.config.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+		});
+
+		// 202 Accepted is success for notifications
+		if (!response.ok && response.status !== 202) {
+			const text = await response.text();
+			throw new Error(`HTTP ${response.status}: ${text}`);
+		}
+	}
+
+	async close(): Promise<void> {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Abort SSE listener
+		if (this.sseConnection) {
+			this.sseConnection.abort();
+			this.sseConnection = null;
+		}
+
+		// Send session termination if we have a session
+		if (this.sessionId) {
+			try {
+				const headers: Record<string, string> = {
+					...this.config.headers,
+					"Mcp-Session-Id": this.sessionId,
+				};
+
+				await fetch(this.config.url, {
+					method: "DELETE",
+					headers,
+				});
+			} catch {
+				// Ignore termination errors
+			}
+			this.sessionId = null;
+		}
+
+		this.onClose?.();
+	}
+}
+
+/**
+ * Create and connect an HTTP transport.
+ */
+export async function createHttpTransport(config: MCPHttpServerConfig | MCPSseServerConfig): Promise<HttpTransport> {
+	const transport = new HttpTransport(config);
+	await transport.connect();
+	return transport;
+}

package/src/core/mcp/transports/index.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP transport exports.
+ */
+
+export { createHttpTransport, HttpTransport } from "./http";
+export { createStdioTransport, StdioTransport } from "./stdio";

package/src/core/mcp/transports/stdio.ts

@@ -0,0 +1,252 @@
+/**
+ * MCP stdio transport.
+ *
+ * Implements JSON-RPC 2.0 over subprocess stdin/stdout.
+ * Messages are newline-delimited JSON.
+ */
+
+import { type Subprocess, spawn } from "bun";
+import type { JsonRpcResponse, MCPStdioServerConfig, MCPTransport } from "../types";
+
+/** Generate unique request ID */
+function generateId(): string {
+	return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+/**
+ * Stdio transport for MCP servers.
+ * Spawns a subprocess and communicates via stdin/stdout.
+ */
+export class StdioTransport implements MCPTransport {
+	private process: Subprocess<"pipe", "pipe", "pipe"> | null = null;
+	private pendingRequests = new Map<
+		string | number,
+		{
+			resolve: (value: unknown) => void;
+			reject: (error: Error) => void;
+		}
+	>();
+	private buffer = "";
+	private _connected = false;
+	private readLoop: Promise<void> | null = null;
+
+	onClose?: () => void;
+	onError?: (error: Error) => void;
+	onNotification?: (method: string, params: unknown) => void;
+
+	constructor(private config: MCPStdioServerConfig) {}
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	/**
+	 * Start the subprocess and begin reading.
+	 */
+	async connect(): Promise<void> {
+		if (this._connected) return;
+
+		const args = this.config.args ?? [];
+		const env = {
+			...process.env,
+			...this.config.env,
+		};
+
+		this.process = spawn({
+			cmd: [this.config.command, ...args],
+			cwd: this.config.cwd ?? process.cwd(),
+			env,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		this._connected = true;
+
+		// Start reading stdout
+		this.readLoop = this.startReadLoop();
+
+		// Log stderr for debugging
+		this.startStderrLoop();
+	}
+
+	private async startReadLoop(): Promise<void> {
+		if (!this.process?.stdout) return;
+
+		const reader = this.process.stdout.getReader();
+		const decoder = new TextDecoder();
+
+		try {
+			while (this._connected) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				this.buffer += decoder.decode(value, { stream: true });
+				this.processBuffer();
+			}
+		} catch (error) {
+			if (this._connected) {
+				this.onError?.(error instanceof Error ? error : new Error(String(error)));
+			}
+		} finally {
+			reader.releaseLock();
+			this.handleClose();
+		}
+	}
+
+	private async startStderrLoop(): Promise<void> {
+		if (!this.process?.stderr) return;
+
+		const reader = this.process.stderr.getReader();
+		const decoder = new TextDecoder();
+
+		try {
+			while (this._connected) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				// Log stderr but don't treat as error - servers use it for logging
+				const text = decoder.decode(value, { stream: true });
+				if (text.trim()) {
+					// Could expose via onStderr callback if needed
+					// For now, silent - MCP spec says clients MAY capture/ignore
+				}
+			}
+		} catch {
+			// Ignore stderr read errors
+		} finally {
+			reader.releaseLock();
+		}
+	}
+
+	private processBuffer(): void {
+		const lines = this.buffer.split("\n");
+		// Keep incomplete last line in buffer
+		this.buffer = lines.pop() ?? "";
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+
+			try {
+				const message = JSON.parse(trimmed) as JsonRpcResponse;
+				this.handleMessage(message);
+			} catch {
+				// Ignore malformed lines
+			}
+		}
+	}
+
+	private handleMessage(message: JsonRpcResponse): void {
+		// Check if it's a response (has id)
+		if ("id" in message && message.id !== null) {
+			const pending = this.pendingRequests.get(message.id);
+			if (pending) {
+				this.pendingRequests.delete(message.id);
+				if (message.error) {
+					pending.reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
+				} else {
+					pending.resolve(message.result);
+				}
+			}
+		} else if ("method" in message) {
+			// It's a notification from server
+			const notification = message as { method: string; params?: unknown };
+			this.onNotification?.(notification.method, notification.params);
+		}
+	}
+
+	private handleClose(): void {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Reject all pending requests
+		for (const [, pending] of this.pendingRequests) {
+			pending.reject(new Error("Transport closed"));
+		}
+		this.pendingRequests.clear();
+
+		this.onClose?.();
+	}
+
+	async request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T> {
+		if (!this._connected || !this.process?.stdin) {
+			throw new Error("Transport not connected");
+		}
+
+		const id = generateId();
+		const request = {
+			jsonrpc: "2.0" as const,
+			id,
+			method,
+			params: params ?? {},
+		};
+
+		return new Promise<T>((resolve, reject) => {
+			this.pendingRequests.set(id, {
+				resolve: resolve as (value: unknown) => void,
+				reject,
+			});
+
+			const message = `${JSON.stringify(request)}\n`;
+			try {
+				// Bun's FileSink has write() method directly
+				this.process!.stdin.write(message);
+				this.process!.stdin.flush();
+			} catch (error: unknown) {
+				this.pendingRequests.delete(id);
+				reject(error);
+			}
+		});
+	}
+
+	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
+		if (!this._connected || !this.process?.stdin) {
+			throw new Error("Transport not connected");
+		}
+
+		const notification = {
+			jsonrpc: "2.0" as const,
+			method,
+			params: params ?? {},
+		};
+
+		const message = `${JSON.stringify(notification)}\n`;
+		// Bun's FileSink has write() method directly
+		this.process.stdin.write(message);
+		this.process.stdin.flush();
+	}
+
+	async close(): Promise<void> {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Reject pending requests
+		for (const [, pending] of this.pendingRequests) {
+			pending.reject(new Error("Transport closed"));
+		}
+		this.pendingRequests.clear();
+
+		// Kill subprocess
+		if (this.process) {
+			this.process.kill();
+			this.process = null;
+		}
+
+		// Wait for read loop to finish
+		if (this.readLoop) {
+			await this.readLoop.catch(() => {});
+			this.readLoop = null;
+		}
+
+		this.onClose?.();
+	}
+}
+
+/**
+ * Create and connect a stdio transport.
+ */
+export async function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport> {
+	const transport = new StdioTransport(config);
+	await transport.connect();
+	return transport;
+}