@thinkwell/conductor 0.5.4 → 0.5.6

package/dist/mcp-bridge/http-listener.js

@@ -1,224 +1,128 @@
-/**
- * HTTP Listener for MCP Bridge
- *
- * Listens on an ephemeral HTTP port for MCP connections from agents
- * and bridges them to ACP `_mcp/*` messages.
- *
- * The listener handles the Streamable HTTP transport for MCP:
- * - POST requests for JSON-RPC messages
- * - SSE responses for streaming
- */
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
-import { isJsonRpcRequest, isJsonRpcNotification, createResponder, } from "@thinkwell/protocol";
-/**
- * Create an HTTP listener for MCP connections
- *
- * The listener waits for the session ID before accepting connections,
- * ensuring we can always correlate connections with sessions.
- */
+import { isJsonRpcRequest, isJsonRpcNotification, createResponder } from "@thinkwell/protocol";
 export async function createHttpListener(options) {
-    const { acpUrl, onMessage } = options;
-    let sessionId = null;
-    const connections = new Map();
-    const sockets = new Set();
-    let server = null;
-    // Create HTTP server
-    server = createServer(async (req, res) => {
-        // CORS headers for local development
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS, GET");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
-        if (req.method === "OPTIONS") {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (req.method === "GET") {
-            // GET request is for SSE stream - return 204 to acknowledge
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (req.method !== "POST") {
-            res.writeHead(405, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Method not allowed" }));
-            return;
-        }
-        try {
-            // Parse the request body first - don't wait for session ID
-            const body = await readBody(req);
-            const message = JSON.parse(body);
-            // Get or create connection for this request
-            // For simplicity, we use a single connection per listener
-            // (in practice, MCP typically uses one connection per session)
-            let connection = connections.get("default");
-            if (!connection) {
-                const connectionId = randomUUID();
-                // Use a placeholder session ID - it will be set later
-                // The session ID is not needed for MCP protocol messages
-                connection = {
-                    connectionId,
-                    sessionId: sessionId ?? "pending",
-                    pendingResponses: new Map(),
-                };
-                connections.set("default", connection);
-                // Notify conductor of new connection
-                onMessage({
-                    type: "connection-received",
-                    acpUrl,
-                    sessionId: connection.sessionId,
-                    connectionId,
-                    send: (responseData) => {
-                        // This is called when conductor sends a response back
-                        // We need to route it to the right pending response
-                    },
-                    close: () => {
-                        connections.delete("default");
-                    },
-                });
-            }
-            // Handle the message
-            await handleMessage(connection, message, res, onMessage);
-        }
-        catch (error) {
-            console.error("MCP bridge HTTP error:", error);
-            res.writeHead(500, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Internal server error" }));
-        }
-    });
-    // Listen on an ephemeral port
-    await new Promise((resolve, reject) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-        server.on("error", reject);
-    });
-    // Track all socket connections so we can destroy them on close
-    server.on('connection', (socket) => {
-        sockets.add(socket);
-        socket.on('close', () => {
-            sockets.delete(socket);
-        });
-    });
-    const address = server.address();
-    if (!address || typeof address === "string") {
-        throw new Error("Failed to get server address");
+  const { acpUrl, onMessage } = options;
+  let sessionId = null;
+  const connections = /* @__PURE__ */ new Map(), sockets = /* @__PURE__ */ new Set();
+  let server = null;
+  server = createServer(async (req, res) => {
+    if (res.setHeader("Access-Control-Allow-Origin", "*"), res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS, GET"), res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id"), req.method === "OPTIONS") {
+      res.writeHead(204), res.end();
+      return;
     }
-    const port = address.port;
-    return {
-        acpUrl,
-        port,
-        setSessionId(id) {
-            sessionId = id;
-            // Update any existing connections with the real session ID
-            for (const conn of connections.values()) {
-                conn.sessionId = id;
-            }
-        },
-        async close() {
-            // Close all connections
-            for (const [key, conn] of connections) {
-                onMessage({
-                    type: "connection-closed",
-                    connectionId: conn.connectionId,
-                });
-                connections.delete(key);
-            }
-            // Destroy all active sockets to allow server to close immediately
-            for (const socket of sockets) {
-                socket.destroy();
-            }
-            sockets.clear();
-            // Close the server
-            if (server) {
-                await new Promise((resolve, reject) => {
-                    server.close((err) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        else {
-                            resolve();
-                        }
-                    });
-                });
-            }
-        },
-    };
-}
-/**
- * Handle an incoming MCP message
- */
-async function handleMessage(connection, message, res, onMessage) {
-    if (isJsonRpcRequest(message)) {
-        // Use string key for the pending responses map
-        const idKey = String(message.id);
-        // Create a promise to wait for the response
-        const responsePromise = new Promise((resolve) => {
-            connection.pendingResponses.set(idKey, resolve);
-        });
-        // Create a dispatch with a responder that sends the response to HTTP
-        const dispatch = {
-            type: "request",
-            id: message.id,
-            method: message.method,
-            params: message.params,
-            responder: createResponder((result) => {
-                const resolver = connection.pendingResponses.get(idKey);
-                connection.pendingResponses.delete(idKey);
-                resolver?.({ jsonrpc: "2.0", id: message.id, result });
-            }, (error) => {
-                const resolver = connection.pendingResponses.get(idKey);
-                connection.pendingResponses.delete(idKey);
-                resolver?.({ jsonrpc: "2.0", id: message.id, error });
-            }),
-        };
-        // Notify conductor of the request
-        onMessage({
-            type: "client-message",
-            connectionId: connection.connectionId,
-            dispatch,
-        });
-        // Wait for the response
-        const response = await responsePromise;
-        // Return JSON-RPC response directly
-        // Include Mcp-Session-Id header per MCP Streamable HTTP spec
-        res.writeHead(200, {
-            "Content-Type": "application/json",
-            "Mcp-Session-Id": connection.connectionId,
+    if (req.method === "GET") {
+      res.writeHead(204), res.end();
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+    try {
+      const body = await readBody(req), message = JSON.parse(body);
+      let connection = connections.get("default");
+      if (!connection) {
+        const connectionId = randomUUID();
+        connection = {
+          connectionId,
+          sessionId: sessionId ?? "pending",
+          pendingResponses: /* @__PURE__ */ new Map()
+        }, connections.set("default", connection), onMessage({
+          type: "connection-received",
+          acpUrl,
+          sessionId: connection.sessionId,
+          connectionId,
+          send: (responseData) => {
+          },
+          close: () => {
+            connections.delete("default");
+          }
         });
-        res.end(JSON.stringify(response));
+      }
+      await handleMessage(connection, message, res, onMessage);
+    } catch (error) {
+      console.error("MCP bridge HTTP error:", error), res.writeHead(500, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: "Internal server error" }));
     }
-    else if (isJsonRpcNotification(message)) {
-        // Create a notification dispatch
-        const dispatch = {
-            type: "notification",
-            method: message.method,
-            params: message.params,
-        };
-        // Notify conductor
+  }), await new Promise((resolve, reject) => {
+    server.listen(0, "127.0.0.1", () => resolve()), server.on("error", reject);
+  }), server.on("connection", (socket) => {
+    sockets.add(socket), socket.on("close", () => {
+      sockets.delete(socket);
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address == "string")
+    throw new Error("Failed to get server address");
+  const port = address.port;
+  return {
+    acpUrl,
+    port,
+    setSessionId(id) {
+      sessionId = id;
+      for (const conn of connections.values())
+        conn.sessionId = id;
+    },
+    async close() {
+      for (const [key, conn] of connections)
         onMessage({
-            type: "client-message",
-            connectionId: connection.connectionId,
-            dispatch,
+          type: "connection-closed",
+          connectionId: conn.connectionId
+        }), connections.delete(key);
+      for (const socket of sockets)
+        socket.destroy();
+      sockets.clear(), server && await new Promise((resolve, reject) => {
+        server.close((err) => {
+          err ? reject(err) : resolve();
         });
-        // Notifications don't have responses
-        res.writeHead(202);
-        res.end();
-    }
-    else {
-        // Unknown message type
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Invalid message type" }));
+      });
     }
+  };
 }
-/**
- * Read the request body as a string
- */
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
-        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-        req.on("error", reject);
+async function handleMessage(connection, message, res, onMessage) {
+  if (isJsonRpcRequest(message)) {
+    const idKey = String(message.id), responsePromise = new Promise((resolve) => {
+      connection.pendingResponses.set(idKey, resolve);
+    }), dispatch = {
+      type: "request",
+      id: message.id,
+      method: message.method,
+      params: message.params,
+      responder: createResponder((result) => {
+        const resolver = connection.pendingResponses.get(idKey);
+        connection.pendingResponses.delete(idKey), resolver?.({ jsonrpc: "2.0", id: message.id, result });
+      }, (error) => {
+        const resolver = connection.pendingResponses.get(idKey);
+        connection.pendingResponses.delete(idKey), resolver?.({ jsonrpc: "2.0", id: message.id, error });
+      })
+    };
+    onMessage({
+      type: "client-message",
+      connectionId: connection.connectionId,
+      dispatch
     });
+    const response = await responsePromise;
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Mcp-Session-Id": connection.connectionId
+    }), res.end(JSON.stringify(response));
+  } else if (isJsonRpcNotification(message)) {
+    const dispatch = {
+      type: "notification",
+      method: message.method,
+      params: message.params
+    };
+    onMessage({
+      type: "client-message",
+      connectionId: connection.connectionId,
+      dispatch
+    }), res.writeHead(202), res.end();
+  } else
+    res.writeHead(400, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: "Invalid message type" }));
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk)), req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8"))), req.on("error", reject);
+  });
 }
-//# sourceMappingURL=http-listener.js.map

package/dist/mcp-bridge/index.js

@@ -1,8 +1,2 @@
-/**
- * MCP Bridge module
- *
- * Provides bridging between MCP-over-ACP and traditional HTTP-based MCP.
- */
 export { McpBridge } from "./mcp-bridge.js";
 export { createHttpListener } from "./http-listener.js";
-//# sourceMappingURL=index.js.map

package/dist/mcp-bridge/mcp-bridge.js

@@ -1,170 +1,123 @@
-/**
- * MCP Bridge
- *
- * The MCP bridge manages HTTP listeners for `acp:` URLs and coordinates
- * the transformation of MCP server configurations during session creation.
- *
- * Key responsibilities:
- * 1. Transform `acp:$UUID` URLs to `http://localhost:$PORT` during session/new
- * 2. Spawn HTTP listeners for each `acp:` URL
- * 3. Route MCP messages between agents and proxies via `_mcp/*` messages
- * 4. Manage connection lifecycle
- */
 import { createHttpListener } from "./http-listener.js";
-/**
- * MCP Bridge manager
- *
- * Manages HTTP listeners and connection lifecycle for MCP-over-ACP bridging.
- */
 export class McpBridge {
-    messageQueue;
-    // Maps acp:uuid → HttpListener
-    listeners = new Map();
-    // Maps connectionId → ActiveMcpConnection
-    connections = new Map();
-    // Pending sessions waiting for session ID
-    pendingSessions = new Map();
-    constructor(options) {
-        this.messageQueue = options.messageQueue;
+  messageQueue;
+  // Maps acp:uuid → HttpListener
+  listeners = /* @__PURE__ */ new Map();
+  // Maps connectionId → ActiveMcpConnection
+  connections = /* @__PURE__ */ new Map();
+  // Pending sessions waiting for session ID
+  pendingSessions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.messageQueue = options.messageQueue;
+  }
+  /**
+   * Transform MCP servers in a session/new request
+   *
+   * For each `acp:` URL:
+   * 1. Spawn an HTTP listener on an ephemeral port
+   * 2. Replace the URL with `http://localhost:$PORT`
+   *
+   * Returns the transformed server list and a session key for later correlation.
+   */
+  async transformMcpServers(servers, sessionKey) {
+    if (!servers || servers.length === 0)
+      return { transformedServers: servers, hasAcpServers: !1 };
+    const pendingSession = {
+      listeners: [],
+      urlMap: /* @__PURE__ */ new Map()
+    }, transformedServers = [];
+    let hasAcpServers = !1;
+    for (const server of servers)
+      if (server.url.startsWith("acp:")) {
+        hasAcpServers = !0;
+        const listener = await createHttpListener({
+          acpUrl: server.url,
+          onMessage: (msg) => this.handleBridgeMessage(msg)
+        });
+        this.listeners.set(server.url, listener), pendingSession.listeners.push(listener), pendingSession.urlMap.set(server.url, `http://127.0.0.1:${listener.port}`), transformedServers.push({
+          ...server,
+          url: `http://127.0.0.1:${listener.port}`,
+          type: "http"
+        });
+      } else
+        transformedServers.push(server);
+    return hasAcpServers && this.pendingSessions.set(sessionKey, pendingSession), { transformedServers, hasAcpServers };
+  }
+  /**
+   * Complete session creation after receiving the session ID from the agent
+   *
+   * This delivers the session ID to all pending listeners so they can
+   * correlate connections with the session.
+   */
+  completeSession(sessionKey, sessionId) {
+    const pending = this.pendingSessions.get(sessionKey);
+    if (pending) {
+      for (const listener of pending.listeners)
+        listener.setSessionId(sessionId);
+      this.pendingSessions.delete(sessionKey);
     }
-    /**
-     * Transform MCP servers in a session/new request
-     *
-     * For each `acp:` URL:
-     * 1. Spawn an HTTP listener on an ephemeral port
-     * 2. Replace the URL with `http://localhost:$PORT`
-     *
-     * Returns the transformed server list and a session key for later correlation.
-     */
-    async transformMcpServers(servers, sessionKey) {
-        if (!servers || servers.length === 0) {
-            return { transformedServers: servers, hasAcpServers: false };
-        }
-        const pendingSession = {
-            listeners: [],
-            urlMap: new Map(),
-        };
-        const transformedServers = [];
-        let hasAcpServers = false;
-        for (const server of servers) {
-            if (server.url.startsWith("acp:")) {
-                hasAcpServers = true;
-                // Spawn HTTP listener for this acp: URL
-                const listener = await createHttpListener({
-                    acpUrl: server.url,
-                    onMessage: (msg) => this.handleBridgeMessage(msg),
-                });
-                this.listeners.set(server.url, listener);
-                pendingSession.listeners.push(listener);
-                pendingSession.urlMap.set(server.url, `http://127.0.0.1:${listener.port}`);
-                // Transform to HTTP URL
-                transformedServers.push({
-                    ...server,
-                    url: `http://127.0.0.1:${listener.port}`,
-                    type: "http",
-                });
-            }
-            else {
-                // Pass through non-acp servers unchanged
-                transformedServers.push(server);
-            }
-        }
-        if (hasAcpServers) {
-            this.pendingSessions.set(sessionKey, pendingSession);
-        }
-        return { transformedServers, hasAcpServers };
+  }
+  /**
+   * Cancel a pending session (e.g., on error)
+   */
+  async cancelSession(sessionKey) {
+    const pending = this.pendingSessions.get(sessionKey);
+    if (pending) {
+      for (const listener of pending.listeners)
+        await listener.close(), this.listeners.delete(listener.acpUrl);
+      this.pendingSessions.delete(sessionKey);
     }
-    /**
-     * Complete session creation after receiving the session ID from the agent
-     *
-     * This delivers the session ID to all pending listeners so they can
-     * correlate connections with the session.
-     */
-    completeSession(sessionKey, sessionId) {
-        const pending = this.pendingSessions.get(sessionKey);
-        if (!pending)
-            return;
-        for (const listener of pending.listeners) {
-            listener.setSessionId(sessionId);
-        }
-        this.pendingSessions.delete(sessionKey);
-    }
-    /**
-     * Cancel a pending session (e.g., on error)
-     */
-    async cancelSession(sessionKey) {
-        const pending = this.pendingSessions.get(sessionKey);
-        if (!pending)
-            return;
-        for (const listener of pending.listeners) {
-            await listener.close();
-            this.listeners.delete(listener.acpUrl);
-        }
-        this.pendingSessions.delete(sessionKey);
-    }
-    /**
-     * Handle a message from an HTTP listener
-     */
-    handleBridgeMessage(msg) {
-        switch (msg.type) {
-            case "connection-received": {
-                // Track the new connection
-                this.connections.set(msg.connectionId, {
-                    connectionId: msg.connectionId,
-                    acpUrl: msg.acpUrl,
-                    sessionId: msg.sessionId,
-                    responder: null,
-                });
-                // Queue the connection notification for the conductor
-                this.messageQueue.push({
-                    type: "mcp-connection-received",
-                    acpUrl: msg.acpUrl,
-                    connectionId: msg.connectionId,
-                });
-                break;
-            }
-            case "client-message": {
-                // Route MCP message to conductor
-                this.messageQueue.push({
-                    type: "mcp-client-to-server",
-                    connectionId: msg.connectionId,
-                    dispatch: msg.dispatch,
-                });
-                break;
-            }
-            case "connection-closed": {
-                // Clean up connection
-                this.connections.delete(msg.connectionId);
-                // Queue disconnect notification
-                this.messageQueue.push({
-                    type: "mcp-connection-disconnected",
-                    connectionId: msg.connectionId,
-                });
-                break;
-            }
-        }
-    }
-    /**
-     * Get connection info by connection ID
-     */
-    getConnection(connectionId) {
-        return this.connections.get(connectionId);
-    }
-    /**
-     * Close all listeners and connections
-     */
-    async close() {
-        // Close all connections
-        this.connections.clear();
-        // Close all listeners
-        for (const listener of this.listeners.values()) {
-            await listener.close();
-        }
-        this.listeners.clear();
-        // Cancel pending sessions
-        for (const key of this.pendingSessions.keys()) {
-            await this.cancelSession(key);
-        }
+  }
+  /**
+   * Handle a message from an HTTP listener
+   */
+  handleBridgeMessage(msg) {
+    switch (msg.type) {
+      case "connection-received": {
+        this.connections.set(msg.connectionId, {
+          connectionId: msg.connectionId,
+          acpUrl: msg.acpUrl,
+          sessionId: msg.sessionId,
+          responder: null
+        }), this.messageQueue.push({
+          type: "mcp-connection-received",
+          acpUrl: msg.acpUrl,
+          connectionId: msg.connectionId
+        });
+        break;
+      }
+      case "client-message": {
+        this.messageQueue.push({
+          type: "mcp-client-to-server",
+          connectionId: msg.connectionId,
+          dispatch: msg.dispatch
+        });
+        break;
+      }
+      case "connection-closed": {
+        this.connections.delete(msg.connectionId), this.messageQueue.push({
+          type: "mcp-connection-disconnected",
+          connectionId: msg.connectionId
+        });
+        break;
+      }
     }
+  }
+  /**
+   * Get connection info by connection ID
+   */
+  getConnection(connectionId) {
+    return this.connections.get(connectionId);
+  }
+  /**
+   * Close all listeners and connections
+   */
+  async close() {
+    this.connections.clear();
+    for (const listener of this.listeners.values())
+      await listener.close();
+    this.listeners.clear();
+    for (const key of this.pendingSessions.keys())
+      await this.cancelSession(key);
+  }
 }
-//# sourceMappingURL=mcp-bridge.js.map

package/dist/mcp-bridge/types.js

@@ -1,8 +1 @@
-/**
- * Types for the MCP Bridge
- *
- * The MCP bridge enables agents without native MCP-over-ACP support
- * to work with proxy components that provide MCP servers using ACP transport.
- */
 export {};
-//# sourceMappingURL=types.js.map