chrome-ai-bridge 2.2.0 → 2.3.1

package/README.md

@@ -263,6 +263,7 @@ npm run cdp:gemini
 | [Technical Spec](docs/SPEC.md) | Detailed architecture and implementation |
 | [Setup Guide](docs/user/setup.md) | Detailed MCP configuration |
 | [Troubleshooting](docs/user/troubleshooting.md) | Problem solving |
+| [CI Policy](docs/ci-policy.md) | Required checks and browser E2E lane policy |
 | [Technical Spec - Architecture](docs/SPEC.md#1-architecture-overview) | Extension architecture |
 
 ---

package/build/src/config.js

@@ -36,6 +36,17 @@ export const GEMINI_CONFIG = {
      */
     BASE_URL: 'https://gemini.google.com/',
 };
+/**
+ * IPC configuration for multi-client MCP support.
+ * The Primary instance exposes an HTTP endpoint on this port;
+ * Secondary instances connect as stdio-to-HTTP proxies.
+ */
+export const IPC_CONFIG = {
+    port: Number(process.env.CAI_IPC_PORT) || 9321,
+    host: '127.0.0.1',
+    healthPath: '/health',
+    mcpPath: '/mcp',
+};
 /**
  * Get session configuration from environment variables or defaults.
  */

package/build/src/main.js

@@ -8,6 +8,9 @@
  *
  * This MCP server provides ChatGPT/Gemini integration via Chrome extension.
  * Puppeteer has been removed - all browser interaction is via WebSocket relay.
+ *
+ * Multi-client: The first instance becomes Primary (stdio + IPC HTTP).
+ * Subsequent instances become Proxies that forward stdio to the Primary via HTTP.
  */
 import assert from 'node:assert';
 import fs from 'node:fs';
@@ -28,7 +31,9 @@ import { getFastContext } from './fast-cdp/fast-context.js';
 import { cleanupAllConnections } from './fast-cdp/fast-chat.js';
 import { generateAgentId, setAgentId } from './fast-cdp/agent-context.js';
 import { cleanupStaleSessions } from './fast-cdp/session-manager.js';
-import { getSessionConfig } from './config.js';
+import { getSessionConfig, IPC_CONFIG } from './config.js';
+import { acquireLock, releaseLock, killSiblings, checkExistingPrimary, updateLockPort } from './process-lock.js';
+import { checkPrimaryHealth, startProxyMode } from './stdio-http-proxy.js';
 function readPackageJson() {
     const currentDir = import.meta.dirname;
     const packageJsonPath = path.join(currentDir, '..', '..', 'package.json');
@@ -51,6 +56,28 @@ logger(`Starting Chrome AI Bridge v${version} (Extension-only mode)`);
 // Initialize agent ID for Agent Teams support
 const agentId = generateAgentId();
 setAgentId(agentId);
+// ─── Multi-client routing ───
+// Check if a Primary instance is already running.
+// If yes and healthy, enter proxy mode (never returns).
+const existingPrimary = checkExistingPrimary();
+if (existingPrimary && existingPrimary.port > 0) {
+    const healthy = await checkPrimaryHealth(existingPrimary.port);
+    if (healthy) {
+        logger(`[main] Primary is healthy (port=${existingPrimary.port}). Entering proxy mode.`);
+        await startProxyMode(existingPrimary.port); // never returns
+    }
+    logger(`[main] Primary (port=${existingPrimary.port}) not healthy. Starting as Primary.`);
+}
+// ─── Primary mode ───
+// Kill all stale sibling processes first
+const killed = await killSiblings();
+if (killed > 0) {
+    logger(`[process-lock] Killed ${killed} stale sibling process(es)`);
+}
+// Generate a unique instance ID (survives PID reuse)
+const instanceId = randomUUID();
+// Acquire exclusive process lock (writes port + instanceId to lock file)
+await acquireLock(IPC_CONFIG.port, instanceId);
 // Start session cleanup timer
 const sessionConfig = getSessionConfig();
 const cleanupTimer = setInterval(async () => {
@@ -161,6 +188,145 @@ const transport = new StdioServerTransport();
 await server.connect(transport);
 logger('Chrome AI Bridge MCP Server connected');
 logDisclaimers();
+// ─── IPC HTTP server (for proxy clients) ───
+{
+    const ipcTransports = {};
+    const ipcServer = http.createServer(async (req, res) => {
+        if (!req.url || !req.method) {
+            res.writeHead(400).end();
+            return;
+        }
+        const url = new URL(req.url, `http://${IPC_CONFIG.host}:${IPC_CONFIG.port}`);
+        // Health endpoint
+        if (url.pathname === IPC_CONFIG.healthPath) {
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({ status: 'ok', pid: process.pid, version, instanceId }));
+            return;
+        }
+        // MCP endpoint
+        if (url.pathname !== IPC_CONFIG.mcpPath) {
+            res.writeHead(404).end();
+            return;
+        }
+        // CORS for local usage
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Headers', 'content-type,mcp-session-id');
+        res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204).end();
+            return;
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        if (req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => {
+                body += chunk;
+            });
+            req.on('end', async () => {
+                let json;
+                try {
+                    json = body ? JSON.parse(body) : null;
+                }
+                catch {
+                    res.writeHead(400).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: { code: -32700, message: 'Parse error' },
+                        id: null,
+                    }));
+                    return;
+                }
+                let ipcTransport;
+                if (sessionId && ipcTransports[sessionId]) {
+                    ipcTransport = ipcTransports[sessionId];
+                }
+                else if (!sessionId && isInitializeRequest(json)) {
+                    ipcTransport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => randomUUID(),
+                        onsessioninitialized: newSessionId => {
+                            ipcTransports[newSessionId] = ipcTransport;
+                        },
+                    });
+                    ipcTransport.onclose = () => {
+                        if (ipcTransport?.sessionId) {
+                            delete ipcTransports[ipcTransport.sessionId];
+                        }
+                    };
+                    await server.connect(ipcTransport);
+                }
+                else {
+                    res.writeHead(400).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: No valid session ID provided',
+                        },
+                        id: null,
+                    }));
+                    return;
+                }
+                try {
+                    await ipcTransport.handleRequest(req, res, json);
+                }
+                catch (error) {
+                    if (!res.headersSent) {
+                        res.writeHead(500).end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: {
+                                code: -32603,
+                                message: error instanceof Error
+                                    ? error.message
+                                    : String(error),
+                            },
+                            id: null,
+                        }));
+                    }
+                }
+            });
+            return;
+        }
+        if (req.method === 'GET' || req.method === 'DELETE') {
+            if (!sessionId || !ipcTransports[sessionId]) {
+                res.writeHead(400).end('Invalid or missing session ID');
+                return;
+            }
+            try {
+                await ipcTransports[sessionId].handleRequest(req, res);
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    res.writeHead(500).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                        id: null,
+                    }));
+                }
+            }
+            return;
+        }
+        res.writeHead(405).end();
+    });
+    function onListening() {
+        const addr = ipcServer.address();
+        const actualPort = typeof addr === 'object' && addr ? addr.port : IPC_CONFIG.port;
+        if (actualPort !== IPC_CONFIG.port) {
+            logger(`[ipc] Configured port ${IPC_CONFIG.port} was unavailable. Using dynamic port ${actualPort}.`);
+            updateLockPort(actualPort);
+        }
+        logger(`[ipc] IPC HTTP listening on http://${IPC_CONFIG.host}:${actualPort} (health: ${IPC_CONFIG.healthPath}, mcp: ${IPC_CONFIG.mcpPath})`);
+    }
+    ipcServer.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            logger(`[ipc] Port ${IPC_CONFIG.port} in use. Retrying with dynamic port...`);
+            ipcServer.listen(0, IPC_CONFIG.host, onListening);
+        }
+        else {
+            logger(`[ipc] IPC server error: ${err.message}`);
+        }
+    });
+    ipcServer.listen(IPC_CONFIG.port, IPC_CONFIG.host, onListening);
+}
 // Graceful shutdown handler with timeout
 // Based on review: タイムアウト必須、強制終了タイマー必要
 let isShuttingDown = false;
@@ -179,6 +345,8 @@ async function shutdown(reason) {
         return;
     isShuttingDown = true;
     logger(`Shutting down: ${reason}`);
+    // Release lock early so a new instance can start immediately
+    releaseLock();
     // Force exit timer (5 seconds) - prevents zombie if cleanup hangs
     const forceExitTimer = setTimeout(() => {
         logger('Graceful shutdown timed out. Forcing exit.');
@@ -207,10 +375,12 @@ process.on('SIGTERM', () => shutdown('SIGTERM'));
 process.on('SIGINT', () => shutdown('SIGINT'));
 // Keep beforeExit for edge cases where stdin doesn't close
 process.on('beforeExit', () => {
+    releaseLock();
     if (logFile) {
         logFile.close();
     }
 });
+// ─── Optional: User-configured external HTTP server (MCP_HTTP_PORT) ───
 const httpPortRaw = process.env.MCP_HTTP_PORT;
 if (httpPortRaw) {
     const httpPort = Number(httpPortRaw);

package/build/src/process-lock.js

@@ -0,0 +1,262 @@
+/**
+ * Process lock management using exclusive file lock.
+ *
+ * Lock file stores JSON: {pid, port, startedAt}
+ * Multi-client mode: alive processes are NOT killed — Secondary
+ * instances connect to the Primary via HTTP proxy instead.
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { logger } from './logger.js';
+const LOCK_DIR = path.join(os.homedir(), '.cache', 'chrome-ai-bridge');
+const LOCK_FILE = path.join(LOCK_DIR, 'mcp.lock');
+let lockFd = null;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Read lock file content. Supports both JSON (new) and plain PID (legacy).
+ */
+export function readLockInfo() {
+    try {
+        const content = fs.readFileSync(LOCK_FILE, 'utf-8').trim();
+        if (!content)
+            return null;
+        // Try JSON format first
+        if (content.startsWith('{')) {
+            const parsed = JSON.parse(content);
+            if (parsed.pid && parsed.pid > 0) {
+                return {
+                    pid: parsed.pid,
+                    port: parsed.port ?? 0,
+                    startedAt: parsed.startedAt ?? '',
+                    instanceId: parsed.instanceId ?? '',
+                };
+            }
+            return null;
+        }
+        // Legacy: plain PID number
+        const pid = Number(content);
+        if (Number.isFinite(pid) && pid > 0) {
+            return { pid, port: 0, startedAt: '', instanceId: '' };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if an existing Primary is alive and reachable.
+ * Reads the lock file and checks process liveness.
+ */
+export function checkExistingPrimary() {
+    const info = readLockInfo();
+    if (!info)
+        return null;
+    if (!isProcessAlive(info.pid)) {
+        logger(`[process-lock] Stale lock (pid=${info.pid}, not running).`);
+        return null;
+    }
+    return { alive: true, port: info.port, instanceId: info.instanceId };
+}
+/**
+ * Try to create lock file exclusively (wx flag).
+ * Writes JSON {pid, port, startedAt}.
+ * Returns the file descriptor on success, null on EEXIST.
+ */
+function tryCreateLock(port, instanceId) {
+    try {
+        fs.mkdirSync(LOCK_DIR, { recursive: true });
+        const fd = fs.openSync(LOCK_FILE, 'wx');
+        const lockInfo = {
+            pid: process.pid,
+            port,
+            startedAt: new Date().toISOString(),
+            instanceId,
+        };
+        fs.writeSync(fd, JSON.stringify(lockInfo));
+        return fd;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'EEXIST') {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Handle an existing lock file.
+ * In multi-client mode, alive processes are NOT killed.
+ * Only stale (dead process) locks are removed.
+ * Returns true if the stale lock was removed and retry is possible.
+ * Returns false if the lock holder is alive (should enter proxy mode).
+ */
+async function handleExistingLock() {
+    const info = readLockInfo();
+    if (info === null) {
+        logger('[process-lock] Corrupted lock file found. Removing.');
+        try {
+            fs.unlinkSync(LOCK_FILE);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    // Don't conflict with ourselves
+    if (info.pid === process.pid) {
+        try {
+            fs.unlinkSync(LOCK_FILE);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    if (!isProcessAlive(info.pid)) {
+        logger(`[process-lock] Stale lock (pid=${info.pid}, not running). Removing.`);
+        try {
+            fs.unlinkSync(LOCK_FILE);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    // Process is alive — do NOT kill. Caller should enter proxy mode.
+    logger(`[process-lock] Primary is alive (pid=${info.pid}, port=${info.port}). Cannot acquire lock.`);
+    return false;
+}
+/**
+ * Acquire an exclusive process lock. Call once at startup for Primary mode.
+ *
+ * Flow:
+ * 1. Try fs.openSync(LOCK_FILE, 'wx') for atomic exclusive creation
+ * 2. Success -> write JSON {pid, port, startedAt}, hold FD
+ * 3. EEXIST -> check holder; remove only if stale, retry once
+ * 4. If holder is alive -> throw (caller should enter proxy mode)
+ */
+export async function acquireLock(port, instanceId) {
+    const fd = tryCreateLock(port, instanceId);
+    if (fd !== null) {
+        lockFd = fd;
+        logger(`[process-lock] Lock acquired (pid=${process.pid}, port=${port}, instanceId=${instanceId.slice(0, 8)})`);
+        return;
+    }
+    // Lock file exists - handle the existing holder
+    const canRetry = await handleExistingLock();
+    if (!canRetry) {
+        throw new Error('[process-lock] Primary is alive. Use proxy mode.');
+    }
+    // Retry once after stale removal
+    const fd2 = tryCreateLock(port, instanceId);
+    if (fd2 !== null) {
+        lockFd = fd2;
+        logger(`[process-lock] Lock acquired after cleanup (pid=${process.pid}, port=${port})`);
+        return;
+    }
+    throw new Error('[process-lock] Failed to acquire lock after retry');
+}
+/**
+ * Update the port in an existing lock file (e.g. after dynamic port fallback).
+ * Rewrites the lock file content while keeping the FD open.
+ */
+export function updateLockPort(newPort) {
+    if (lockFd === null) {
+        logger('[process-lock] Cannot update port: no lock held.');
+        return;
+    }
+    const info = readLockInfo();
+    if (!info) {
+        logger('[process-lock] Cannot update port: lock file unreadable.');
+        return;
+    }
+    info.port = newPort;
+    // Truncate and rewrite
+    fs.ftruncateSync(lockFd);
+    const buf = Buffer.from(JSON.stringify(info));
+    fs.writeSync(lockFd, buf, 0, buf.length, 0);
+    logger(`[process-lock] Lock port updated to ${newPort}`);
+}
+/**
+ * Release the process lock. Call during shutdown.
+ */
+export function releaseLock() {
+    if (lockFd !== null) {
+        try {
+            fs.closeSync(lockFd);
+        }
+        catch { /* ignore */ }
+        lockFd = null;
+    }
+    try {
+        fs.unlinkSync(LOCK_FILE);
+    }
+    catch { /* ignore */ }
+    logger('[process-lock] Lock released.');
+}
+/**
+ * Kill all sibling chrome-ai-bridge processes (bulk cleanup).
+ *
+ * Uses pgrep to find processes matching 'chrome-ai-bridge/build/src/main.js',
+ * excludes self and parent, then SIGTERM -> wait -> SIGKILL survivors.
+ *
+ * Returns the number of processes killed.
+ * On pgrep failure (e.g. not installed), returns 0 silently.
+ */
+export async function killSiblings() {
+    let pids;
+    try {
+        const output = execFileSync('pgrep', ['-f', 'chrome-ai-bridge/build/src/main.js'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+        });
+        pids = output.trim().split('\n')
+            .map(s => Number(s.trim()))
+            .filter(n => Number.isFinite(n) && n > 0);
+    }
+    catch {
+        // pgrep returns exit code 1 when no matches, or not available
+        return 0;
+    }
+    // Exclude self and parent (cli.mjs wrapper)
+    const selfPid = process.pid;
+    const parentPid = process.ppid;
+    const targets = pids.filter(pid => pid !== selfPid && pid !== parentPid);
+    if (targets.length === 0) {
+        return 0;
+    }
+    logger(`[process-lock] Found ${targets.length} stale sibling(s): ${targets.join(', ')}`);
+    // Send SIGTERM to all
+    for (const pid of targets) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // Process already gone
+        }
+    }
+    // Wait for graceful shutdown
+    await sleep(2000);
+    // SIGKILL survivors
+    let killed = 0;
+    for (const pid of targets) {
+        if (isProcessAlive(pid)) {
+            logger(`[process-lock] Process ${pid} still alive after SIGTERM. Sending SIGKILL...`);
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // ignore
+            }
+        }
+        killed++;
+    }
+    return killed;
+}

package/build/src/stdio-http-proxy.js

@@ -0,0 +1,157 @@
+/**
+ * stdio-to-HTTP proxy for multi-client MCP support.
+ *
+ * When a Primary MCP server is already running, Secondary instances
+ * start in proxy mode: they bridge stdio (for Claude Code) to the
+ * Primary's Streamable HTTP endpoint.
+ *
+ * Uses MCP SDK transports to avoid custom JSON-RPC parsing.
+ *
+ * Resilience: On Primary disconnect, retries with exponential backoff
+ * (1s, 2s, 4s — max 3 attempts, ~7s total) before giving up.
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { logger } from './logger.js';
+import { IPC_CONFIG } from './config.js';
+import { readLockInfo } from './process-lock.js';
+/**
+ * Check if the Primary's /health endpoint is reachable.
+ * Optionally verifies instanceId matches the lock file.
+ */
+export async function checkPrimaryHealth(port, expectedInstanceId) {
+    try {
+        const resp = await fetch(`http://${IPC_CONFIG.host}:${port}${IPC_CONFIG.healthPath}`, { signal: AbortSignal.timeout(2000) });
+        if (!resp.ok)
+            return false;
+        if (expectedInstanceId) {
+            const body = (await resp.json());
+            if (body.instanceId && body.instanceId !== expectedInstanceId) {
+                logger(`[proxy] instanceId mismatch: expected=${expectedInstanceId.slice(0, 8)}, got=${body.instanceId.slice(0, 8)}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const RETRY_DELAYS = [1000, 2000, 4000]; // exponential backoff
+/**
+ * Attempt to reconnect to the Primary with exponential backoff.
+ * Re-reads lock file on every attempt (follow-the-leader strategy):
+ * - Port may have changed (dynamic fallback)
+ * - instanceId may have changed (Primary restart)
+ * Returns the current port for reconnection.
+ */
+async function waitForPrimaryRecovery(initialPort) {
+    for (let i = 0; i < RETRY_DELAYS.length; i++) {
+        const delay = RETRY_DELAYS[i];
+        logger(`[proxy] Retry ${i + 1}/${RETRY_DELAYS.length} in ${delay}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        // Re-read lock file each attempt (port/instanceId may have changed)
+        const lockInfo = readLockInfo();
+        if (!lockInfo) {
+            logger('[proxy] Lock file missing or unreadable, retrying...');
+            continue;
+        }
+        const currentPort = lockInfo.port || initialPort;
+        // Follow-the-leader: use lock file's instanceId as truth
+        const expectedId = lockInfo.instanceId || undefined;
+        if (await checkPrimaryHealth(currentPort, expectedId)) {
+            logger(`[proxy] Primary recovered (port=${currentPort})`);
+            return { recovered: true, port: currentPort };
+        }
+    }
+    return { recovered: false, port: initialPort };
+}
+/**
+ * Start in proxy mode: bridge stdio <-> Primary HTTP.
+ *
+ * This function never returns normally — the process exits
+ * when stdin closes or the Primary becomes unreachable after retries.
+ */
+export async function startProxyMode(port) {
+    let currentPort = port;
+    const mcpUrl = new URL(`http://${IPC_CONFIG.host}:${currentPort}${IPC_CONFIG.mcpPath}`);
+    logger(`[proxy] Entering proxy mode -> ${mcpUrl}`);
+    const stdio = new StdioServerTransport();
+    let http = new StreamableHTTPClientTransport(mcpUrl);
+    let isReconnecting = false;
+    /**
+     * Try to reconnect to the Primary after disconnect.
+     * Follows the leader: adopts new port/instanceId from lock file.
+     * On success, creates a new HTTP transport and re-wires the bridge.
+     * On failure, exits with code 1.
+     */
+    async function handlePrimaryDisconnect() {
+        if (isReconnecting)
+            return;
+        isReconnecting = true;
+        logger('[proxy] Primary disconnected. Attempting recovery...');
+        const result = await waitForPrimaryRecovery(currentPort);
+        if (!result.recovered) {
+            logger('[proxy] Primary not recovered after retries. Exiting.');
+            process.exit(1);
+        }
+        // Port may have changed after Primary restart
+        currentPort = result.port;
+        const newMcpUrl = new URL(`http://${IPC_CONFIG.host}:${currentPort}${IPC_CONFIG.mcpPath}`);
+        // Create new transport and re-wire
+        try {
+            const newHttp = new StreamableHTTPClientTransport(newMcpUrl);
+            wireHttpTransport(newHttp);
+            await newHttp.start();
+            http = newHttp;
+            isReconnecting = false;
+            logger(`[proxy] Reconnected to Primary (port=${currentPort})`);
+        }
+        catch (err) {
+            logger(`[proxy] Reconnection failed: ${err}`);
+            process.exit(1);
+        }
+    }
+    /**
+     * Wire event handlers for an HTTP transport instance.
+     */
+    function wireHttpTransport(transport) {
+        transport.onmessage = (message) => {
+            stdio.send(message).catch((err) => {
+                logger(`[proxy] Failed to write to stdout: ${err}`);
+            });
+        };
+        transport.onclose = () => {
+            logger('[proxy] HTTP connection to Primary closed');
+            handlePrimaryDisconnect();
+        };
+        transport.onerror = (err) => {
+            logger(`[proxy] HTTP error: ${err.message}`);
+        };
+    }
+    // Bridge: stdin (Claude Code) -> HTTP POST (Primary)
+    stdio.onmessage = (message) => {
+        http.send(message).catch((err) => {
+            logger(`[proxy] Failed to forward to Primary: ${err}`);
+            handlePrimaryDisconnect();
+        });
+    };
+    // Handle stdio close (Claude Code disconnected)
+    stdio.onclose = () => {
+        logger('[proxy] stdio closed');
+        http
+            .terminateSession()
+            .catch(() => { })
+            .finally(() => http.close().catch(() => { }))
+            .finally(() => process.exit(0));
+    };
+    // Wire initial HTTP transport
+    wireHttpTransport(http);
+    // Start HTTP transport first (sets up AbortController),
+    // then stdio (starts reading from stdin).
+    await http.start();
+    await stdio.start();
+    logger('[proxy] Proxy mode active');
+    // Keep process alive; exit is handled by event handlers above.
+    return new Promise(() => { });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "MCP server bridging Chrome extension and AI assistants (ChatGPT, Gemini). Extension-only mode - no Puppeteer.",
   "type": "module",
   "bin": "./scripts/cli.mjs",
@@ -19,7 +19,8 @@
     "check-format": "eslint --cache . && prettier --check --cache .;",
     "start": "npm run build && node build/src/index.js",
     "start-debug": "DEBUG=mcp:* DEBUG_COLORS=false npm run build && node build/src/index.js",
-    "restart-mcp": "bash scripts/restart-mcp.sh",
+    "cleanup": "node scripts/cleanup.mjs",
+    "restart-mcp": "node scripts/cleanup.mjs",
     "test:chatgpt": "npm run build && node scripts/test-fast-chat.mjs chatgpt",
     "test:gemini": "npm run build && node scripts/test-fast-chat.mjs gemini",
     "test:both": "npm run build && node scripts/test-fast-chat.mjs both",
@@ -34,7 +35,11 @@
     "test:mcp:chatgpt": "npm run build && node scripts/test-mcp.mjs --chatgpt",
     "test:mcp:gemini": "npm run build && node scripts/test-mcp.mjs --gemini",
     "test:mcp:parallel": "npm run build && node scripts/test-mcp.mjs --parallel",
-    "test:network": "npm run build && node scripts/test-network-intercept.mjs"
+    "test:network": "npm run build && node scripts/test-network-intercept.mjs",
+    "test": "npm run build:noext && node scripts/test-mcp.mjs --tools-only",
+    "docs": "npm run build:noext && node --experimental-strip-types scripts/generate-docs.ts",
+    "generate-docs": "npm run docs",
+    "sync-server-json-version": "node --experimental-strip-types scripts/sync-server-json-version.ts"
   },
   "files": [
     "build/src",