aipex-mcp-bridge 2.1.0 → 3.1.0

package/README.md

@@ -1,44 +1,39 @@
 # aipex-mcp-bridge
 
-MCP bridge that connects AI agents to the [AIPex](https://aipex.ai) browser extension via WebSocket.
-
-Works with **any** MCP client that supports stdio transport — Cursor, Claude Desktop, Claude Code, VS Code Copilot, Windsurf, Zed, and more.
+MCP server that connects AI agents to the [AIPex](https://aipex.ai) browser extension. Supports **multiple simultaneous clients** (Cursor, Claude Code, VS Code Copilot, etc.) via StreamableHTTP.
 
 ## How it works
 
 ```
-AI Agent (MCP client) ──stdio──▶ aipex-mcp-bridge ──WebSocket──▶ AIPex Chrome Extension
+Cursor        ──HTTP POST /mcp──┐
+Claude Code   ──HTTP POST /mcp──┤── aipex-mcp-server ──WebSocket──▶ AIPex Chrome Extension
+VS Code       ──HTTP POST /mcp──┘
 ```
 
-The bridge starts a WebSocket server on `localhost:9223` (configurable) and communicates with your AI agent over stdio using the MCP protocol. The AIPex extension connects to the WebSocket server to expose browser control tools.
+The server runs on `localhost:9223` and provides:
+- **`/mcp`** — StreamableHTTP endpoint for MCP clients
+- **`/extension`** — WebSocket endpoint for the AIPex Chrome extension
+- **`/health`** — Health check endpoint
 
 ## Quick start
 
-### 1. Configure your AI agent
+### 1. Start the server
 
-Add the following to your agent's MCP configuration:
+```bash
+npx aipex-mcp-server
+```
 
-**Cursor** (`.cursor/mcp.json`):
+The server stays running and handles all AI agent connections.
 
-```json
-{
-  "mcpServers": {
-    "aipex-browser": {
-      "command": "npx",
-      "args": ["-y", "aipex-mcp-bridge"]
-    }
-  }
-}
-```
+### 2. Configure your AI agent
 
-**Claude Desktop** (`claude_desktop_config.json`):
+**Cursor** (`.cursor/mcp.json` or `~/.cursor/mcp.json`):
 
 ```json
 {
   "mcpServers": {
     "aipex-browser": {
-      "command": "npx",
-      "args": ["-y", "aipex-mcp-bridge"]
+      "url": "http://localhost:9223/mcp"
     }
   }
 }
@@ -47,7 +42,7 @@ Add the following to your agent's MCP configuration:
 **Claude Code**:
 
 ```bash
-claude mcp add aipex-browser -- npx -y aipex-mcp-bridge
+claude mcp add --transport http aipex-browser http://localhost:9223/mcp
 ```
 
 **VS Code Copilot** (`.vscode/mcp.json`):
@@ -56,69 +51,57 @@ claude mcp add aipex-browser -- npx -y aipex-mcp-bridge
 {
   "servers": {
     "aipex-browser": {
-      "command": "npx",
-      "args": ["-y", "aipex-mcp-bridge"]
-    }
-  }
-}
-```
-
-**Windsurf** (`mcp_config.json`):
-
-```json
-{
-  "mcpServers": {
-    "aipex-browser": {
-      "command": "npx",
-      "args": ["-y", "aipex-mcp-bridge"]
+      "url": "http://localhost:9223/mcp"
     }
   }
 }
 ```
 
-### 2. Connect AIPex extension
+### 3. Connect AIPex extension
 
 1. Open Chrome → AIPex extension → Options page
-2. Set WebSocket URL to `ws://localhost:9223`
+2. Set WebSocket URL to `ws://localhost:9223/extension`
 3. Click **Connect**
 
-Your AI agent can now control the browser through AIPex.
+Your AI agents can now control the browser through AIPex — all simultaneously.
 
 ## Options
 
 ```
-npx aipex-mcp-bridge [--port <port>] [--host <host>]
+npx aipex-mcp-server [--port <port>] [--host <host>]
 ```
 
-| Option            | Default     | Description                                                 |
-| ----------------- | ----------- | ----------------------------------------------------------- |
-| `--port <port>`   | `9223`      | WebSocket port for AIPex extension                          |
-| `--host <host>`   | `127.0.0.1` | Bind address (`0.0.0.0` to allow remote/Docker connections) |
-| `--help`, `-h`    |             | Show help message                                           |
-| `--version`, `-v` |             | Show version                                                |
+| Option          | Default     | Description                                                 |
+| --------------- | ----------- | ----------------------------------------------------------- |
+| `--port <port>` | `9223`      | Server port                                                 |
+| `--host <host>` | `127.0.0.1` | Bind address (`0.0.0.0` to allow remote/Docker connections) |
+| `--help`, `-h`  |             | Show help message                                           |
+| `--version`, `-v`|            | Show version                                                |
+
+---
+
+## Stdio Bridge (backward compatibility)
 
-### Custom port example
+For MCP clients that only support stdio transport, a thin bridge is included:
 
 ```json
 {
   "mcpServers": {
     "aipex-browser": {
       "command": "npx",
-      "args": ["-y", "aipex-mcp-bridge", "--port", "8080"]
+      "args": ["-y", "aipex-mcp-bridge"]
     }
   }
 }
 ```
 
+The stdio bridge forwards tool calls to the HTTP server at `http://localhost:9223/mcp`. The server must be running separately.
+
 ---
 
 ## AIPex CLI
 
-This package also includes `aipex-cli`, a command-line tool for controlling the browser directly from the terminal without an MCP client.
-
-### Prerequisites
-
-The bridge must be running with the AIPex extension connected. In Docker (`butterman2/aipex-browser`), this is automatic.
+Command-line tool for controlling the browser directly from the terminal.
 
 ### Usage
 
@@ -129,12 +112,6 @@ aipex-cli --help <tool_name>                  # Show tool parameters
 aipex-cli --json '{"name":"...","arguments":{...}}'  # Raw JSON
 ```
 
-### Environment Variables
-
-| Variable       | Default                   | Description             |
-| -------------- | ------------------------- | ----------------------- |
-| `AIPEX_WS_URL` | `ws://localhost:9223/cli` | Bridge CLI endpoint URL |
-
 ### Examples
 
 ```bash
@@ -145,19 +122,18 @@ aipex-cli click --tabId 123 --uid btn-42
 aipex-cli capture_screenshot
 ```
 
-### Docker usage
+### Environment Variables
 
-```bash
-docker exec aipex aipex-cli get_all_tabs
-docker exec aipex aipex-cli create_new_tab --url https://google.com
-```
+| Variable              | Default                           | Description             |
+| --------------------- | --------------------------------- | ----------------------- |
+| `AIPEX_SERVER_URL`    | `http://localhost:9223/mcp`       | HTTP server URL         |
+| `AIPEX_WS_URL`        | `ws://localhost:9223/cli`         | WebSocket fallback URL  |
+| `AIPEX_CONNECT_TIMEOUT`| `60000`                          | Max ms to wait          |
 
 ---
 
 ## Docker Image
 
-The AIPex Docker image provides a fully self-contained browser automation environment:
-
 ```bash
 docker pull butterman2/aipex-browser:latest
 docker run -d --name aipex --shm-size=2g \
@@ -165,25 +141,24 @@ docker run -d --name aipex --shm-size=2g \
   butterman2/aipex-browser:latest
 ```
 
-Multi-architecture support: `linux/amd64` and `linux/arm64`.
-
 | Port | Service              |
 | ---- | -------------------- |
-| 9223 | MCP Bridge WebSocket |
+| 9223 | MCP Server (HTTP + WS) |
 | 5900 | VNC                  |
 | 6080 | noVNC (web-based)    |
 
-### Publishing to DockerHub
+## Migration from v2.x
 
-```bash
-docker login -u butterman2
-docker buildx create --name aipex-builder --use 2>/dev/null || docker buildx use aipex-builder
-docker buildx build \
-  --platform linux/amd64,linux/arm64 \
-  -t butterman2/aipex-browser:latest \
-  -t butterman2/aipex-browser:$(node -p "require('./package.json').version") \
-  --push .
-```
+v3.0 replaces the daemon+proxy architecture with a single HTTP server:
+
+| v2.x (daemon)                              | v3.0 (HTTP server)                        |
+| ------------------------------------------ | ----------------------------------------- |
+| `npx aipex-mcp-bridge` (stdio per IDE)     | `npx aipex-mcp-server` (one server)       |
+| Each IDE spawns its own bridge process      | All IDEs connect to one HTTP endpoint      |
+| Daemon with PID files, idle timeout         | Standard HTTP server, no background process|
+| Extension connects to `ws://localhost:9223` | Extension connects to `ws://localhost:9223/extension` |
+
+**Breaking change**: The AIPex extension WebSocket URL changed from `ws://localhost:9223` to `ws://localhost:9223/extension`. Update the URL in AIPex extension Options.
 
 ## Requirements
 

package/dist/bridge.js

@@ -4,270 +4,193 @@ import {
 } from "./chunk-DHFGE3G7.js";
 
 // src/bridge.ts
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-
-// src/proxy-client.ts
-import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
 import { WebSocket } from "ws";
-var PID_FILE = join(homedir(), ".aipex-mcp-daemon.pid");
-var CONNECT_TIMEOUT_MS = 1e4;
-var CONNECT_RETRY_INTERVAL_MS = 300;
-var TOOL_CALL_TIMEOUT_MS = 6e4;
-function log(msg) {
-  process.stderr.write(`[aipex-bridge] ${msg}
-`);
-}
-var ProxyClient = class {
-  ws = null;
-  nextId = 1;
-  pending = /* @__PURE__ */ new Map();
-  extensionConnected = false;
-  onStatusChange;
-  setStatusHandler(handler) {
-    this.onStatusChange = handler;
-  }
-  isConnected() {
-    return !!this.ws && this.ws.readyState === WebSocket.OPEN;
-  }
-  isExtensionConnected() {
-    return this.extensionConnected;
-  }
-  /**
-   * Connect to the daemon, auto-launching it if needed.
-   */
-  async connect(proxyPort, extPort, host) {
-    const url = `ws://${host}:${proxyPort}`;
-    if (await this.tryConnect(url)) {
-      return;
-    }
-    log("Daemon not running, launching...");
-    await this.launchDaemon(extPort, proxyPort, host);
-    const deadline = Date.now() + CONNECT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-      await sleep(CONNECT_RETRY_INTERVAL_MS);
-      if (await this.tryConnect(url)) {
-        return;
-      }
-    }
-    throw new Error(
-      `Could not connect to daemon at ${url} after ${CONNECT_TIMEOUT_MS / 1e3}s`
-    );
-  }
-  async tryConnect(url) {
-    return new Promise((resolve2) => {
-      const ws = new WebSocket(url);
-      const timer = setTimeout(() => {
-        ws.terminate();
-        resolve2(false);
-      }, 2e3);
-      ws.on("open", () => {
-        clearTimeout(timer);
-        this.attachSocket(ws);
-        resolve2(true);
-      });
-      ws.on("error", () => {
-        clearTimeout(timer);
-        resolve2(false);
-      });
-    });
-  }
-  attachSocket(ws) {
-    this.ws = ws;
-    ws.on("message", (data) => {
-      this.handleMessage(data.toString());
-    });
-    ws.on("close", () => {
-      log("Disconnected from daemon");
-      this.ws = null;
-      this.rejectAll("Disconnected from daemon");
-    });
-    ws.on("error", (err) => {
-      log(`Daemon connection error: ${err.message}`);
-    });
-    log("Connected to daemon");
-  }
-  handleMessage(raw) {
-    let msg;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (msg.method === "status" && msg.params) {
-      const params = msg.params;
-      this.extensionConnected = !!params.extensionConnected;
-      this.onStatusChange?.(this.extensionConnected);
-      return;
-    }
-    const id = msg.id;
-    if (id == null) return;
-    const pending = this.pending.get(id);
-    if (!pending) return;
-    clearTimeout(pending.timer);
-    this.pending.delete(id);
-    if (msg.error) {
-      const err = msg.error;
-      pending.reject(new Error(err.message || "Daemon returned an error"));
-    } else {
-      pending.resolve(msg.result);
-    }
-  }
-  /**
-   * Send a tool call through the daemon to the extension.
-   */
-  async sendToolCall(toolName, args = {}, timeoutMs = TOOL_CALL_TIMEOUT_MS) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error(
-        "Not connected to daemon. The bridge may need to be restarted."
-      );
-    }
-    const id = this.nextId++;
-    const msg = {
-      jsonrpc: "2.0",
-      id,
-      method: "tools/call",
-      params: { name: toolName, arguments: args }
-    };
-    this.ws.send(JSON.stringify(msg));
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pending.has(id)) {
-          this.pending.delete(id);
-          reject(new Error(`Tool '${toolName}' timed out after ${timeoutMs}ms`));
-        }
-      }, timeoutMs);
-      this.pending.set(id, { resolve: resolve2, reject, timer });
-    });
-  }
-  async close() {
-    this.rejectAll("Bridge shutting down");
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  rejectAll(reason) {
-    for (const [, entry] of this.pending) {
-      clearTimeout(entry.timer);
-      entry.reject(new Error(reason));
-    }
-    this.pending.clear();
-  }
-  async launchDaemon(extPort, proxyPort, host) {
-    if (isDaemonAlive()) {
-      log("Daemon PID file exists and process is alive, skipping launch");
-      return;
-    }
-    const daemonScript = getDaemonPath();
-    log(`Launching daemon: node ${daemonScript}`);
-    const child = spawn(
-      process.execPath,
-      [
-        daemonScript,
-        "--port",
-        String(extPort),
-        "--proxy-port",
-        String(proxyPort),
-        "--host",
-        host
-      ],
-      {
-        detached: true,
-        stdio: "ignore",
-        env: { ...process.env }
-      }
-    );
-    child.on("error", (err) => {
-      log(`Failed to launch daemon: ${err.message}`);
-    });
-    child.unref();
-    await sleep(500);
-  }
-};
-function getDaemonPath() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = dirname(thisFile);
-  const candidates = [
-    join(thisDir, "daemon.js"),
-    join(thisDir, "daemon.ts")
-  ];
-  for (const p of candidates) {
-    if (existsSync(p)) return p;
-  }
-  return candidates[0];
-}
-function isDaemonAlive() {
-  try {
-    if (!existsSync(PID_FILE)) return false;
-    const content = readFileSync(PID_FILE, "utf-8").trim();
-    const pid = parseInt(content.split("\n")[0], 10);
-    if (isNaN(pid)) return false;
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/bridge.ts
 var cliArgs = process.argv.slice(2);
 if (cliArgs.includes("--help") || cliArgs.includes("-h")) {
   process.stderr.write(`
 AIPex MCP Bridge \u2014 connect AI agents to AIPex browser extension
 
 Usage:
-  npx aipex-mcp-bridge [--port <port>] [--proxy-port <port>] [--host <host>]
+  npx aipex-mcp-bridge [--port <port>] [--host <host>]
 
 Options:
-  --port <port>        WebSocket port for AIPex extension (default: 9223)
-  --proxy-port <port>  Daemon proxy port (default: 9224)
-  --host <host>        Bind address (default: 127.0.0.1)
-  --help, -h           Show this help message
-  --version, -v        Show version
+  --port <port>  Daemon port (default: 9223)
+  --host <host>  Daemon host (default: 127.0.0.1)
+  --help, -h     Show this help message
+  --version, -v  Show version
 
-Multiple IDEs can run this bridge simultaneously \u2014 they share a single
-daemon process that manages the extension connection.
+The bridge auto-starts a background daemon if one isn't already running.
+Multiple IDE instances (Cursor, Claude Code) can run simultaneously.
 
-After starting, open AIPex extension Options and connect to:
-  ws://localhost:<port>
+After starting, connect AIPex extension \u2192 Options \u2192 ws://localhost:<port>/extension
 `);
   process.exit(0);
 }
 if (cliArgs.includes("--version") || cliArgs.includes("-v")) {
-  process.stderr.write("aipex-mcp-bridge 2.1.0\n");
+  process.stderr.write("aipex-mcp-bridge 3.1.0\n");
   process.exit(0);
 }
 function getArg(name, fallback) {
   const idx = cliArgs.indexOf(name);
   return idx !== -1 && cliArgs[idx + 1] ? cliArgs[idx + 1] : fallback;
 }
-var EXT_PORT = parseInt(getArg("--port", "9223"), 10);
-var PROXY_PORT = parseInt(getArg("--proxy-port", "9224"), 10);
-var WS_HOST = getArg("--host", "127.0.0.1");
-if (isNaN(EXT_PORT) || EXT_PORT < 1 || EXT_PORT > 65535) {
-  process.stderr.write(`Invalid port number. Must be between 1 and 65535.
-`);
-  process.exit(1);
-}
-function log2(msg) {
+var PORT = parseInt(getArg("--port", "9223"), 10);
+var HOST = getArg("--host", "127.0.0.1");
+var DAEMON_URL = `ws://${HOST}:${PORT}/bridge`;
+var MAX_CONNECT_ATTEMPTS = 10;
+var INITIAL_BACKOFF_MS = 300;
+var TOOL_CALL_TIMEOUT_MS = 6e4;
+function log(msg) {
   process.stderr.write(`[aipex-bridge] ${msg}
 `);
 }
-var proxyClient = new ProxyClient();
+var daemonWs;
+var nextReqId = 1;
+var pendingCalls = /* @__PURE__ */ new Map();
+function isDaemonConnected() {
+  return !!daemonWs && daemonWs.readyState === WebSocket.OPEN;
+}
+function sendToolCallToDaemon(toolName, args) {
+  if (!isDaemonConnected()) {
+    return Promise.reject(
+      new Error(
+        "Not connected to AIPex daemon. The daemon may have stopped.\nRestart the bridge or check if port " + PORT + " is available."
+      )
+    );
+  }
+  const id = nextReqId++;
+  const msg = {
+    jsonrpc: "2.0",
+    id,
+    method: "tools/call",
+    params: { name: toolName, arguments: args }
+  };
+  daemonWs.send(JSON.stringify(msg));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      if (pendingCalls.has(id)) {
+        pendingCalls.delete(id);
+        reject(new Error(`Tool '${toolName}' timed out after ${TOOL_CALL_TIMEOUT_MS}ms`));
+      }
+    }, TOOL_CALL_TIMEOUT_MS);
+    pendingCalls.set(id, { resolve, reject, timer });
+  });
+}
+function handleDaemonMessage(raw) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const id = msg.id;
+  if (id == null) return;
+  const pending = pendingCalls.get(id);
+  if (!pending) return;
+  clearTimeout(pending.timer);
+  pendingCalls.delete(id);
+  if (msg.error) {
+    const err = msg.error;
+    pending.reject(new Error(err.message || "Daemon returned an error"));
+  } else {
+    pending.resolve(msg.result);
+  }
+}
+function rejectAllPending(reason) {
+  for (const [, entry] of pendingCalls) {
+    clearTimeout(entry.timer);
+    entry.reject(new Error(reason));
+  }
+  pendingCalls.clear();
+}
+function tryConnectToDaemon() {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(DAEMON_URL);
+    const timeout = setTimeout(() => {
+      ws.terminate();
+      reject(new Error("Connection timeout"));
+    }, 3e3);
+    ws.on("open", () => {
+      clearTimeout(timeout);
+      resolve(ws);
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+function spawnDaemon() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const daemonPath = join(__dirname, "daemon.js");
+  log(`Spawning daemon: ${daemonPath} --port ${PORT} --host ${HOST}`);
+  const child = fork(daemonPath, ["--port", String(PORT), "--host", HOST], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  child.on("error", (err) => {
+    log(`Failed to spawn daemon: ${err.message}`);
+  });
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function connectWithAutoSpawn() {
+  try {
+    const ws = await tryConnectToDaemon();
+    log("Connected to existing daemon");
+    return ws;
+  } catch {
+  }
+  log("No daemon running, spawning one...");
+  spawnDaemon();
+  let backoff = INITIAL_BACKOFF_MS;
+  for (let attempt = 1; attempt <= MAX_CONNECT_ATTEMPTS; attempt++) {
+    await sleep(backoff);
+    try {
+      const ws = await tryConnectToDaemon();
+      log(`Connected to daemon (attempt ${attempt})`);
+      return ws;
+    } catch {
+      backoff = Math.min(backoff * 1.5, 2e3);
+    }
+  }
+  throw new Error(
+    `Failed to connect to daemon after ${MAX_CONNECT_ATTEMPTS} attempts.
+Check if port ${PORT} is available: lsof -i :${PORT}`
+  );
+}
+function setupDaemonConnection(ws) {
+  daemonWs = ws;
+  ws.on("message", (data) => handleDaemonMessage(data.toString()));
+  ws.on("close", () => {
+    log("Daemon connection lost, will reconnect on next tool call");
+    rejectAllPending("Daemon connection lost");
+    daemonWs = void 0;
+  });
+  ws.on("error", (err) => {
+    log(`Daemon WebSocket error: ${err.message}`);
+  });
+}
+async function ensureDaemonConnection() {
+  if (isDaemonConnected()) return;
+  log("Reconnecting to daemon...");
+  const ws = await connectWithAutoSpawn();
+  setupDaemonConnection(ws);
+}
 var server = new Server(
-  { name: "aipex-mcp-bridge", version: "2.1.0" },
+  { name: "aipex-mcp-bridge", version: "3.1.0" },
   { capabilities: { tools: {} } }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -283,7 +206,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     };
   }
   try {
-    const result = await proxyClient.sendToolCall(
+    await ensureDaemonConnection();
+    const result = await sendToolCallToDaemon(
       name,
       args ?? {}
     );
@@ -306,31 +230,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 });
 async function main() {
-  try {
-    await proxyClient.connect(PROXY_PORT, EXT_PORT, WS_HOST);
-  } catch (err) {
-    log2(
-      `Warning: ${err instanceof Error ? err.message : String(err)}`
-    );
-    log2("Will attempt tool calls anyway (daemon may start later)");
-  }
+  const ws = await connectWithAutoSpawn();
+  setupDaemonConnection(ws);
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  log2("AIPex MCP Bridge started (multi-client mode)");
-  log2(`Connected to daemon at ws://${WS_HOST}:${PROXY_PORT}`);
+  log("AIPex MCP Bridge started (stdio \u2192 daemon relay)");
+  log(`Connected to daemon at ${DAEMON_URL}`);
 }
 process.stdin.on("close", async () => {
   setTimeout(() => process.exit(0), 5e3);
+  rejectAllPending("Bridge shutting down");
+  if (daemonWs) daemonWs.close();
   await server.close();
-  await proxyClient.close();
   process.exit(0);
 });
-process.on("SIGINT", async () => {
-  log2("Shutting down...");
-  await proxyClient.close();
+process.on("SIGINT", () => {
+  log("Shutting down...");
+  rejectAllPending("Bridge shutting down");
+  if (daemonWs) daemonWs.close();
   process.exit(0);
 });
 main().catch((err) => {
-  log2(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+  log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
   process.exit(1);
 });

package/dist/cli.js

@@ -4,8 +4,10 @@ import {
 } from "./chunk-DHFGE3G7.js";
 
 // src/cli.ts
-import { spawn } from "child_process";
+import { fork, spawn } from "child_process";
 import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
 import { WebSocket } from "ws";
 var DEFAULT_WS_URL = "ws://localhost:9223/cli";
 var ENTRYPOINT_PATH = "/entrypoint.sh";
@@ -76,8 +78,8 @@ Examples:
   aipex-cli capture_screenshot
 
 Environment:
-  AIPEX_WS_URL            WebSocket URL (default: ws://localhost:9223/cli)
-  AIPEX_CONNECT_TIMEOUT   Max ms to wait for bridge+extension (default: 60000)
+  AIPEX_WS_URL              Daemon WebSocket URL (default: ws://localhost:9223/cli)
+  AIPEX_CONNECT_TIMEOUT     Max ms to wait for daemon (default: 60000)
 `);
 }
 function printToolList() {
@@ -148,7 +150,7 @@ function coerceValue(value, key, props) {
   const schema = props[key];
   const type = schema?.type;
   switch (type) {
-    case "number":
+    case "number": {
       const num = Number(value);
       if (isNaN(num)) {
         process.stderr.write(`--${key} expects a number, got: ${value}
@@ -156,6 +158,7 @@ function coerceValue(value, key, props) {
         process.exit(1);
       }
       return num;
+    }
     case "boolean":
       return value === "true" || value === "1";
     case "array":
@@ -173,12 +176,12 @@ function coerceValue(value, key, props) {
 }
 function isRetryableError(msg) {
   const lower = msg.toLowerCase();
-  return lower.includes("not connected") || lower.includes("extension is not connected") || lower.includes("no extension");
+  return lower.includes("not connected") || lower.includes("extension is not connected") || lower.includes("no extension") || lower.includes("econnrefused") || lower.includes("fetch failed");
 }
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-function attemptToolCall(wsUrl, name, args2) {
+function attemptWsToolCall(wsUrl, name, args2) {
   return new Promise((resolve) => {
     let settled = false;
     const ws = new WebSocket(wsUrl);
@@ -243,11 +246,6 @@ function attemptToolCall(wsUrl, name, args2) {
             return;
           }
           const result = response.result;
-          if (result?.isError && result?.content?.[0]?.text && isRetryableError(result.content[0].text)) {
-            ws.close();
-            resolve({ retry: true, code: 1 });
-            return;
-          }
           if (result?.content && Array.isArray(result.content)) {
             for (const item of result.content) {
               if (item.type === "text" && item.text) {
@@ -279,20 +277,36 @@ function attemptToolCall(wsUrl, name, args2) {
     });
   });
 }
+function spawnDaemon() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const daemonPath = join(__dirname, "daemon.js");
+  try {
+    const child = fork(daemonPath, ["--port", "9223", "--host", "127.0.0.1"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    child.on("error", () => {
+    });
+  } catch {
+  }
+}
 async function runTool(name, args2) {
   const wsUrl = process.env.AIPEX_WS_URL ?? DEFAULT_WS_URL;
   const deadline = Date.now() + MAX_RETRY_TIMEOUT_MS;
   let backoff = INITIAL_BACKOFF_MS;
   let attempt = 0;
+  let daemonSpawned = false;
   while (true) {
     attempt++;
-    const result = await attemptToolCall(wsUrl, name, args2);
+    const result = await attemptWsToolCall(wsUrl, name, args2);
     if (!result.retry) {
       process.exit(result.code);
     }
     if (Date.now() >= deadline) {
       process.stderr.write(
-        `Gave up after ${MAX_RETRY_TIMEOUT_MS / 1e3}s \u2014 bridge or extension not ready at ${wsUrl}
+        `Gave up after ${MAX_RETRY_TIMEOUT_MS / 1e3}s \u2014 daemon not ready at ${wsUrl}
 `
       );
       process.exit(1);
@@ -312,14 +326,13 @@ async function runTool(name, args2) {
         child.on("error", () => {
         });
         child.unref();
-      } else {
-        process.stderr.write(
-          `[aipex-cli] ${ENTRYPOINT_PATH} not found, waiting for external start ...
-`
-        );
+      } else if (!daemonSpawned) {
+        process.stderr.write("[aipex-cli] Spawning daemon...\n");
+        spawnDaemon();
+        daemonSpawned = true;
       }
       process.stderr.write(
-        `[aipex-cli] Waiting for bridge + extension at ${wsUrl} ...
+        `[aipex-cli] Waiting for AIPex daemon + extension ...
 `
       );
     }

package/dist/daemon.js

@@ -5,63 +5,26 @@ import {
 
 // src/daemon.ts
 import { createServer } from "http";
-import { writeFileSync, unlinkSync, existsSync, readFileSync } from "fs";
-import { homedir } from "os";
+import { writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
-import { WebSocketServer, WebSocket } from "ws";
-var PID_FILE = join(homedir(), ".aipex-mcp-daemon.pid");
-var IDLE_TIMEOUT_MS = 3e4;
-var TOOL_CALL_TIMEOUT_MS = 6e4;
-var PING_INTERVAL_MS = 15e3;
-var PING_TIMEOUT_MS = 5e3;
+import { homedir } from "os";
+import { WebSocket, WebSocketServer } from "ws";
 var cliArgs = process.argv.slice(2);
-if (cliArgs.includes("--help") || cliArgs.includes("-h")) {
-  process.stderr.write(`
-AIPex MCP Daemon \u2014 shared backend for multi-client MCP bridge
-
-Usage:
-  aipex-mcp-daemon [--port <port>] [--proxy-port <port>] [--host <host>]
-
-Options:
-  --port <port>        Extension WebSocket port (default: 9223)
-  --proxy-port <port>  Proxy client WebSocket port (default: 9224)
-  --host <host>        Bind address (default: 127.0.0.1)
-  --help, -h           Show this help message
-`);
-  process.exit(0);
-}
 function getArg(name, fallback) {
   const idx = cliArgs.indexOf(name);
   return idx !== -1 && cliArgs[idx + 1] ? cliArgs[idx + 1] : fallback;
 }
-var WS_HOST = getArg("--host", "127.0.0.1");
-var EXT_PORT = parseInt(getArg("--port", "9223"), 10);
-var PROXY_PORT = parseInt(getArg("--proxy-port", "9224"), 10);
+var PORT = parseInt(getArg("--port", "9223"), 10);
+var HOST = getArg("--host", "127.0.0.1");
+var PID_FILE = join(homedir(), ".aipex-daemon.pid");
+var IDLE_TIMEOUT_MS = 3e4;
+var TOOL_CALL_TIMEOUT_MS = 6e4;
+var PING_INTERVAL_MS = 15e3;
+var PING_TIMEOUT_MS = 5e3;
 function log(msg) {
   process.stderr.write(`[aipex-daemon] ${msg}
 `);
 }
-function writePidFile() {
-  try {
-    writeFileSync(PID_FILE, `${process.pid}
-${PROXY_PORT}
-`);
-  } catch {
-    log(`Warning: could not write PID file ${PID_FILE}`);
-  }
-}
-function removePidFile() {
-  try {
-    if (existsSync(PID_FILE)) {
-      const content = readFileSync(PID_FILE, "utf-8").trim();
-      const pid = parseInt(content.split("\n")[0], 10);
-      if (pid === process.pid) {
-        unlinkSync(PID_FILE);
-      }
-    }
-  } catch {
-  }
-}
 var extensionWs;
 var nextExtId = 1;
 var pendingExtCalls = /* @__PURE__ */ new Map();
@@ -73,25 +36,23 @@ function setExtensionSocket(ws) {
   if (extensionWs && extensionWs.readyState === WebSocket.OPEN) {
     extensionWs.close();
   }
-  rejectAllExtPending("New extension connection replaced previous one");
+  rejectAllPendingExt("New extension connection replaced previous one");
   extensionWs = ws;
-  ws.on("message", (data) => {
-    handleExtensionMessage(data.toString());
-  });
+  ws.on("message", (data) => handleExtensionMessage(data.toString()));
   ws.on("close", () => {
     if (extensionWs === ws) {
       log("Extension disconnected");
       stopExtPing();
-      rejectAllExtPending("Extension disconnected");
+      rejectAllPendingExt("Extension disconnected");
       extensionWs = void 0;
-      broadcastStatus();
+      resetIdleTimer();
     }
   });
   ws.on("error", (err) => {
     log(`Extension WebSocket error: ${err.message}`);
   });
   startExtPing();
-  broadcastStatus();
+  resetIdleTimer();
   log("Extension connected");
 }
 function handleExtensionMessage(raw) {
@@ -110,29 +71,32 @@ function handleExtensionMessage(raw) {
   pendingExtCalls.delete(id);
   const response = {
     jsonrpc: "2.0",
-    id: pending.proxyRequestId
+    id: pending.bridgeReqId
   };
   if (msg.error) {
     response.error = msg.error;
   } else {
     response.result = msg.result;
   }
-  if (pending.proxySocket.readyState === WebSocket.OPEN) {
-    pending.proxySocket.send(JSON.stringify(response));
+  if (pending.bridgeSocket.readyState === WebSocket.OPEN) {
+    pending.bridgeSocket.send(JSON.stringify(response));
   }
 }
-function sendToolCallToExtension(toolName, args, proxySocket, proxyRequestId) {
+function forwardToolCall(bridgeSocket, bridgeReqId, toolName, args) {
   if (!isExtensionConnected()) {
-    const errResponse = {
+    const errResp = {
       jsonrpc: "2.0",
-      id: proxyRequestId,
+      id: bridgeReqId,
       error: {
         code: -1,
-        message: "AIPex extension is not connected. To connect:\n1. Open Chrome \u2192 AIPex extension \u2192 Options page\n2. Click the Connect button\n3. The extension will connect automatically."
+        message: `AIPex extension is not connected. To connect:
+1. Open Chrome \u2192 AIPex extension \u2192 Options page
+2. Set WebSocket URL to ws://localhost:${PORT}/extension
+3. Click Connect`
       }
     };
-    if (proxySocket.readyState === WebSocket.OPEN) {
-      proxySocket.send(JSON.stringify(errResponse));
+    if (bridgeSocket.readyState === WebSocket.OPEN) {
+      bridgeSocket.send(JSON.stringify(errResp));
     }
     return;
   }
@@ -147,31 +111,31 @@ function sendToolCallToExtension(toolName, args, proxySocket, proxyRequestId) {
   const timer = setTimeout(() => {
     if (pendingExtCalls.has(extId)) {
       pendingExtCalls.delete(extId);
-      const errResponse = {
+      const timeoutResp = {
         jsonrpc: "2.0",
-        id: proxyRequestId,
+        id: bridgeReqId,
         error: {
           code: -1,
           message: `Tool '${toolName}' timed out after ${TOOL_CALL_TIMEOUT_MS}ms`
         }
       };
-      if (proxySocket.readyState === WebSocket.OPEN) {
-        proxySocket.send(JSON.stringify(errResponse));
+      if (bridgeSocket.readyState === WebSocket.OPEN) {
+        bridgeSocket.send(JSON.stringify(timeoutResp));
       }
     }
   }, TOOL_CALL_TIMEOUT_MS);
-  pendingExtCalls.set(extId, { proxySocket, proxyRequestId, timer });
+  pendingExtCalls.set(extId, { bridgeSocket, bridgeReqId, timer });
 }
-function rejectAllExtPending(reason) {
-  for (const [id, entry] of pendingExtCalls) {
+function rejectAllPendingExt(reason) {
+  for (const [, entry] of pendingExtCalls) {
     clearTimeout(entry.timer);
-    const errResponse = {
+    const errResp = {
       jsonrpc: "2.0",
-      id: entry.proxyRequestId,
+      id: entry.bridgeReqId,
       error: { code: -1, message: reason }
     };
-    if (entry.proxySocket.readyState === WebSocket.OPEN) {
-      entry.proxySocket.send(JSON.stringify(errResponse));
+    if (entry.bridgeSocket.readyState === WebSocket.OPEN) {
+      entry.bridgeSocket.send(JSON.stringify(errResp));
     }
   }
   pendingExtCalls.clear();
@@ -194,8 +158,8 @@ function startExtPing() {
       }
     }, PING_TIMEOUT_MS);
     pendingExtCalls.set(id, {
-      proxySocket: null,
-      proxyRequestId: -1,
+      bridgeSocket: extensionWs,
+      bridgeReqId: `ping-${id}`,
       timer
     });
   }, PING_INTERVAL_MS);
@@ -206,21 +170,8 @@ function stopExtPing() {
     extPingInterval = null;
   }
 }
-var proxyClients = /* @__PURE__ */ new Set();
-var idleTimer = null;
-function broadcastStatus() {
-  const statusMsg = JSON.stringify({
-    jsonrpc: "2.0",
-    method: "status",
-    params: { extensionConnected: isExtensionConnected() }
-  });
-  for (const client of proxyClients) {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(statusMsg);
-    }
-  }
-}
-function handleProxyMessage(socket, raw) {
+var bridgeClients = /* @__PURE__ */ new Set();
+function handleBridgeMessage(socket, raw) {
   let msg;
   try {
     msg = JSON.parse(raw);
@@ -229,21 +180,17 @@ function handleProxyMessage(socket, raw) {
   }
   const id = msg.id;
   const method = msg.method;
-  if (method === "tools/list") {
-    socket.send(
-      JSON.stringify({
-        jsonrpc: "2.0",
-        id,
-        result: { tools: toolSchemas }
-      })
-    );
-    return;
-  }
   if (method === "tools/call") {
     const params = msg.params ?? {};
     const name = params.name;
     const args = params.arguments ?? {};
-    sendToolCallToExtension(name, args, socket, id ?? 0);
+    forwardToolCall(socket, id ?? 0, name, args);
+    return;
+  }
+  if (method === "tools/list") {
+    socket.send(
+      JSON.stringify({ jsonrpc: "2.0", id, result: { tools: toolSchemas } })
+    );
     return;
   }
   if (method === "ping") {
@@ -255,137 +202,138 @@ function handleProxyMessage(socket, raw) {
       JSON.stringify({
         jsonrpc: "2.0",
         id,
-        result: { extensionConnected: isExtensionConnected() }
+        result: {
+          extensionConnected: isExtensionConnected(),
+          bridgeClients: bridgeClients.size
+        }
       })
     );
     return;
   }
 }
-function cleanupPendingForProxy(socket) {
-  for (const [id, entry] of pendingExtCalls) {
-    if (entry.proxySocket === socket) {
-      clearTimeout(entry.timer);
-      pendingExtCalls.delete(id);
-    }
-  }
-}
-function startIdleTimer() {
-  stopIdleTimer();
-  idleTimer = setTimeout(() => {
-    if (proxyClients.size === 0) {
-      log(`No proxy clients connected for ${IDLE_TIMEOUT_MS / 1e3}s, exiting`);
-      shutdown();
-    }
-  }, IDLE_TIMEOUT_MS);
+function handleCliMessage(socket, raw) {
+  handleBridgeMessage(socket, raw);
 }
-function stopIdleTimer() {
+var idleTimer = null;
+function resetIdleTimer() {
   if (idleTimer) {
     clearTimeout(idleTimer);
     idleTimer = null;
   }
+  if (bridgeClients.size === 0 && !isExtensionConnected()) {
+    idleTimer = setTimeout(() => {
+      log(`No connections for ${IDLE_TIMEOUT_MS / 1e3}s, shutting down`);
+      shutdown();
+    }, IDLE_TIMEOUT_MS);
+  }
 }
-var extHttpServer = createServer();
-var extWss = new WebSocketServer({ server: extHttpServer });
-extWss.on("connection", (socket, req) => {
-  const addr = req.socket.remoteAddress ?? "unknown";
+var httpServer = createServer((req, res) => {
+  if (req.url === "/health" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        status: "ok",
+        extensionConnected: isExtensionConnected(),
+        bridgeClients: bridgeClients.size,
+        version: "3.1.0"
+      })
+    );
+    return;
+  }
+  res.writeHead(404).end("Not found");
+});
+var extensionWss = new WebSocketServer({ noServer: true });
+var bridgeWss = new WebSocketServer({ noServer: true });
+var cliWss = new WebSocketServer({ noServer: true });
+httpServer.on("upgrade", (req, socket, head) => {
   const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
-  if (pathname === "/cli") {
-    log(`CLI client connected from ${addr}`);
-    socket.on("message", (data) => {
-      handleProxyMessage(socket, data.toString());
+  if (pathname === "/extension" || pathname === "/") {
+    extensionWss.handleUpgrade(req, socket, head, (ws) => {
+      extensionWss.emit("connection", ws, req);
     });
-    return;
+  } else if (pathname === "/bridge") {
+    bridgeWss.handleUpgrade(req, socket, head, (ws) => {
+      bridgeWss.emit("connection", ws, req);
+    });
+  } else if (pathname === "/cli") {
+    cliWss.handleUpgrade(req, socket, head, (ws) => {
+      cliWss.emit("connection", ws, req);
+    });
+  } else {
+    socket.destroy();
   }
+});
+extensionWss.on("connection", (socket, req) => {
+  const addr = req.socket.remoteAddress ?? "unknown";
   log(`Extension connected from ${addr}`);
   setExtensionSocket(socket);
 });
-extWss.on("error", (err) => {
-  log(`Extension WebSocket server error: ${err.message}`);
-});
-var proxyHttpServer = createServer();
-var proxyWss = new WebSocketServer({ server: proxyHttpServer });
-proxyWss.on("connection", (socket, req) => {
-  const addr = req.socket.remoteAddress ?? "unknown";
-  log(`Proxy client connected from ${addr} (total: ${proxyClients.size + 1})`);
-  proxyClients.add(socket);
-  stopIdleTimer();
-  const statusMsg = JSON.stringify({
-    jsonrpc: "2.0",
-    method: "status",
-    params: { extensionConnected: isExtensionConnected() }
-  });
-  socket.send(statusMsg);
-  socket.on("message", (data) => {
-    handleProxyMessage(socket, data.toString());
-  });
+bridgeWss.on("connection", (socket) => {
+  bridgeClients.add(socket);
+  resetIdleTimer();
+  log(`Bridge client connected (total: ${bridgeClients.size})`);
+  socket.on("message", (data) => handleBridgeMessage(socket, data.toString()));
   socket.on("close", () => {
-    proxyClients.delete(socket);
-    cleanupPendingForProxy(socket);
-    log(`Proxy client disconnected (remaining: ${proxyClients.size})`);
-    if (proxyClients.size === 0) {
-      startIdleTimer();
-    }
+    bridgeClients.delete(socket);
+    resetIdleTimer();
+    log(`Bridge client disconnected (total: ${bridgeClients.size})`);
   });
   socket.on("error", (err) => {
-    log(`Proxy client error: ${err.message}`);
+    log(`Bridge client error: ${err.message}`);
   });
 });
-proxyWss.on("error", (err) => {
-  log(`Proxy WebSocket server error: ${err.message}`);
+cliWss.on("connection", (socket) => {
+  bridgeClients.add(socket);
+  resetIdleTimer();
+  socket.on("message", (data) => handleCliMessage(socket, data.toString()));
+  socket.on("close", () => {
+    bridgeClients.delete(socket);
+    resetIdleTimer();
+  });
+});
+function writePidFile() {
+  try {
+    writeFileSync(PID_FILE, String(process.pid));
+  } catch {
+  }
+}
+function removePidFile() {
+  try {
+    unlinkSync(PID_FILE);
+  } catch {
+  }
+}
+httpServer.listen(PORT, HOST, () => {
+  writePidFile();
+  log(`AIPex MCP Daemon started (v3.1.0) pid=${process.pid}`);
+  log(`Extension WS:  ws://${HOST}:${PORT}/extension`);
+  log(`Bridge WS:     ws://${HOST}:${PORT}/bridge`);
+  log(`CLI WS:        ws://${HOST}:${PORT}/cli`);
+  log(`Health:        http://${HOST}:${PORT}/health`);
+  resetIdleTimer();
+});
+httpServer.on("error", (err) => {
+  if (err.code === "EADDRINUSE") {
+    log(`Port ${PORT} already in use \u2014 another daemon is likely running`);
+    process.exit(0);
+  }
+  log(`Server error: ${err.message}`);
+  process.exit(1);
 });
 function shutdown() {
-  log("Shutting down daemon...");
   stopExtPing();
-  stopIdleTimer();
-  rejectAllExtPending("Daemon shutting down");
+  rejectAllPendingExt("Daemon shutting down");
   if (extensionWs) {
     extensionWs.close();
     extensionWs = void 0;
   }
-  for (const client of proxyClients) {
-    client.close();
-  }
-  proxyClients.clear();
-  extWss.close();
-  proxyWss.close();
-  extHttpServer.close();
-  proxyHttpServer.close();
+  extensionWss.close();
+  bridgeWss.close();
+  cliWss.close();
+  httpServer.close();
   removePidFile();
+  if (idleTimer) clearTimeout(idleTimer);
   process.exit(0);
 }
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-async function main() {
-  await new Promise((resolve, reject) => {
-    extHttpServer.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        log(`Extension port ${EXT_PORT} is already in use. Another daemon may be running.`);
-        process.exit(1);
-      }
-      reject(err);
-    });
-    extHttpServer.listen(EXT_PORT, WS_HOST, resolve);
-  });
-  await new Promise((resolve, reject) => {
-    proxyHttpServer.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        log(`Proxy port ${PROXY_PORT} is already in use. Another daemon may be running.`);
-        extHttpServer.close();
-        process.exit(1);
-      }
-      reject(err);
-    });
-    proxyHttpServer.listen(PROXY_PORT, WS_HOST, resolve);
-  });
-  writePidFile();
-  startIdleTimer();
-  log(`AIPex MCP Daemon started (PID: ${process.pid})`);
-  log(`Extension WebSocket: ws://${WS_HOST}:${EXT_PORT}`);
-  log(`Proxy WebSocket:     ws://${WS_HOST}:${PROXY_PORT}`);
-  log(`Waiting for connections...`);
-}
-main().catch((err) => {
-  log(`Fatal error: ${err instanceof Error ? err.message : String(err)}`);
-  removePidFile();
-  process.exit(1);
-});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aipex-mcp-bridge",
-  "version": "2.1.0",
-  "description": "MCP bridge that connects AI agents (Cursor, Claude, VS Code Copilot, etc.) to the AIPex browser extension via WebSocket",
+  "version": "3.1.0",
+  "description": "MCP bridge that connects AI agents (Cursor, Claude Code, VS Code Copilot, etc.) to the AIPex browser extension. Auto-spawns a shared daemon to support multiple simultaneous clients.",
   "type": "module",
   "bin": {
     "aipex-mcp-bridge": "./dist/bridge.js",
@@ -14,10 +14,11 @@
   ],
   "scripts": {
     "build": "tsup",
-    "dev": "tsx src/bridge.ts"
+    "dev": "tsx src/bridge.ts",
+    "dev:daemon": "tsx src/daemon.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.8.0",
+    "@modelcontextprotocol/sdk": "^1.28.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {