chrome-ai-bridge 2.3.1 → 2.3.3

package/build/src/config.js

@@ -58,7 +58,30 @@ export function getSessionConfig() {
     };
     return {
         sessionTtlMinutes: raw.ttl > 0 ? raw.ttl : 30,
-        maxAgents: raw.max > 0 ? Math.floor(raw.max) : 10,
+        maxAgents: raw.max > 0 ? Math.floor(raw.max) : 20,
         cleanupIntervalMinutes: raw.interval > 0 ? raw.interval : 5,
     };
 }
+/**
+ * Get IPC overload protection settings from environment variables or defaults.
+ */
+export function getIpcGuardConfig() {
+    const raw = {
+        maxSessions: Number(process.env.CAI_IPC_MAX_SESSIONS),
+        maxQueue: Number(process.env.CAI_IPC_MAX_QUEUE),
+        queueWaitTimeoutMs: Number(process.env.CAI_IPC_QUEUE_WAIT_TIMEOUT_MS),
+        sessionIdleMs: Number(process.env.CAI_IPC_SESSION_IDLE_MS),
+        startupDelayJitterMs: Number(process.env.CAI_STARTUP_DELAY_JITTER_MS),
+        startupProcessThreshold: Number(process.env.CAI_STARTUP_PROCESS_THRESHOLD),
+    };
+    return {
+        maxSessions: raw.maxSessions > 0 ? Math.floor(raw.maxSessions) : 16,
+        maxQueue: raw.maxQueue > 0 ? Math.floor(raw.maxQueue) : 64,
+        queueWaitTimeoutMs: raw.queueWaitTimeoutMs > 0 ? Math.floor(raw.queueWaitTimeoutMs) : 10_000,
+        sessionIdleMs: raw.sessionIdleMs > 0 ? Math.floor(raw.sessionIdleMs) : 300_000,
+        startupDelayJitterMs: raw.startupDelayJitterMs > 0 ? Math.floor(raw.startupDelayJitterMs) : 1_500,
+        startupProcessThreshold: raw.startupProcessThreshold > 0
+            ? Math.floor(raw.startupProcessThreshold)
+            : 8,
+    };
+}

package/build/src/main.js

@@ -15,6 +15,7 @@
 import assert from 'node:assert';
 import fs from 'node:fs';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import http from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -31,8 +32,8 @@ 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, IPC_CONFIG } from './config.js';
-import { acquireLock, releaseLock, killSiblings, checkExistingPrimary, updateLockPort } from './process-lock.js';
+import { getIpcGuardConfig, getSessionConfig, IPC_CONFIG } from './config.js';
+import { releaseLock, tryAcquireLockSafe, checkExistingPrimary, updateLockPort } from './process-lock.js';
 import { checkPrimaryHealth, startProxyMode } from './stdio-http-proxy.js';
 function readPackageJson() {
     const currentDir = import.meta.dirname;
@@ -56,28 +57,87 @@ 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
+// ─── Multi-client routing with retry ───
+// Handles concurrent startup of many processes (e.g. tproj 16-pane scenario).
+// Each process tries to become Primary or fall back to Proxy mode,
+// with exponential backoff + jitter to avoid thundering herd.
+const MAX_STARTUP_ATTEMPTS = 5;
+const BASE_DELAY_MS = 300;
+const HEALTH_CHECK_RETRIES = 3;
+const HEALTH_CHECK_INTERVAL_MS = 500;
+const ipcGuardConfig = getIpcGuardConfig();
+const instanceId = randomUUID();
+let becamePrimary = false;
+function countLocalBridgeInstances() {
+    try {
+        const output = execFileSync('ps', ['-axo', 'command'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const lines = output.split('\n').filter(Boolean);
+        return lines.filter(line => line.includes('chrome-ai-bridge') &&
+            (line.includes('build/src/main.js') || line.includes('scripts/cli.mjs'))).length;
+    }
+    catch {
+        return 0;
     }
-    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)`);
+async function applyStartupJitterIfNeeded() {
+    const instanceCount = countLocalBridgeInstances();
+    if (instanceCount < ipcGuardConfig.startupProcessThreshold) {
+        return;
+    }
+    const delayMs = Math.floor(Math.random() * ipcGuardConfig.startupDelayJitterMs);
+    logger(`[main] High startup concurrency detected (${instanceCount} processes). Applying jitter=${delayMs}ms.`);
+    await new Promise(resolve => setTimeout(resolve, delayMs));
 }
-// 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);
+await applyStartupJitterIfNeeded();
+for (let attempt = 0; attempt < MAX_STARTUP_ATTEMPTS; attempt++) {
+    // 1. Try to become Primary (non-throwing)
+    const lockAcquired = await tryAcquireLockSafe(IPC_CONFIG.port, instanceId);
+    if (lockAcquired) {
+        becamePrimary = true;
+        break;
+    }
+    // 2. Lock held by another process — try to connect as Proxy
+    const existingPrimary = checkExistingPrimary();
+    if (existingPrimary && existingPrimary.port > 0) {
+        for (let hc = 0; hc < HEALTH_CHECK_RETRIES; hc++) {
+            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
+            }
+            if (hc < HEALTH_CHECK_RETRIES - 1) {
+                const jitter = Math.random() * HEALTH_CHECK_INTERVAL_MS;
+                await new Promise(r => setTimeout(r, HEALTH_CHECK_INTERVAL_MS + jitter));
+            }
+        }
+        logger(`[main] Primary (port=${existingPrimary.port}) not healthy after ${HEALTH_CHECK_RETRIES} retries.`);
+    }
+    // 3. Neither Primary nor Proxy — backoff with jitter and retry
+    if (attempt < MAX_STARTUP_ATTEMPTS - 1) {
+        const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+        const jitter = Math.random() * BASE_DELAY_MS;
+        const delay = backoff + jitter;
+        logger(`[main] Startup attempt ${attempt + 1}/${MAX_STARTUP_ATTEMPTS} failed. Retrying in ${Math.round(delay)}ms...`);
+        await new Promise(r => setTimeout(r, delay));
+    }
+}
+if (!becamePrimary) {
+    // Final fallback: one last proxy attempt before giving up
+    const existingPrimary = checkExistingPrimary();
+    if (existingPrimary && existingPrimary.port > 0) {
+        const healthy = await checkPrimaryHealth(existingPrimary.port);
+        if (healthy) {
+            logger(`[main] Final fallback: entering proxy mode (port=${existingPrimary.port}).`);
+            await startProxyMode(existingPrimary.port); // never returns
+        }
+    }
+    logger('[main] Failed to start as Primary or Proxy after all retries. Exiting.');
+    process.exit(1);
+}
+// ─── Primary mode ───
 // Start session cleanup timer
 const sessionConfig = getSessionConfig();
 const cleanupTimer = setInterval(async () => {
@@ -191,6 +251,75 @@ logDisclaimers();
 // ─── IPC HTTP server (for proxy clients) ───
 {
     const ipcTransports = {};
+    const ipcSessionLastActivity = new Map();
+    const initQueue = [];
+    let initializingCount = 0;
+    const getSessionLoad = () => Object.keys(ipcTransports).length + initializingCount;
+    const touchIpcSession = (sessionId) => {
+        ipcSessionLastActivity.set(sessionId, Date.now());
+    };
+    const cleanupIpcSession = (sessionId) => {
+        if (ipcTransports[sessionId]) {
+            delete ipcTransports[sessionId];
+        }
+        ipcSessionLastActivity.delete(sessionId);
+        drainInitQueue();
+    };
+    function sendJsonRpcError(res, code, message, id = null, statusCode = 400) {
+        res.writeHead(statusCode).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code, message },
+            id,
+        }));
+    }
+    function drainInitQueue() {
+        while (initQueue.length > 0 && getSessionLoad() < ipcGuardConfig.maxSessions) {
+            const waiter = initQueue.shift();
+            if (!waiter)
+                break;
+            clearTimeout(waiter.timeout);
+            waiter.resolve();
+        }
+    }
+    async function waitForInitCapacity() {
+        if (getSessionLoad() < ipcGuardConfig.maxSessions) {
+            return;
+        }
+        if (initQueue.length >= ipcGuardConfig.maxQueue) {
+            throw new Error('SERVER_QUEUE_FULL');
+        }
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const index = initQueue.findIndex(item => item.resolve === resolve);
+                if (index >= 0) {
+                    initQueue.splice(index, 1);
+                }
+                reject(new Error('SERVER_BUSY_TIMEOUT'));
+            }, ipcGuardConfig.queueWaitTimeoutMs);
+            timeout.unref();
+            initQueue.push({ resolve, reject, timeout });
+        });
+    }
+    const idleCleanupTimer = setInterval(async () => {
+        const now = Date.now();
+        const staleSessionIds = Array.from(ipcSessionLastActivity.entries())
+            .filter(([, lastActivity]) => now - lastActivity > ipcGuardConfig.sessionIdleMs)
+            .map(([sessionId]) => sessionId);
+        if (staleSessionIds.length === 0) {
+            return;
+        }
+        logger(`[ipc] Closing ${staleSessionIds.length} idle session(s) older than ${ipcGuardConfig.sessionIdleMs}ms.`);
+        for (const staleSessionId of staleSessionIds) {
+            try {
+                await ipcTransports[staleSessionId]?.close();
+            }
+            catch {
+                // Ignore transport close errors and continue cleanup.
+            }
+            cleanupIpcSession(staleSessionId);
+        }
+    }, Math.max(10_000, Math.min(60_000, Math.floor(ipcGuardConfig.sessionIdleMs / 2))));
+    idleCleanupTimer.unref();
     const ipcServer = http.createServer(async (req, res) => {
         if (!req.url || !req.method) {
             res.writeHead(400).end();
@@ -199,7 +328,15 @@ logDisclaimers();
         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 }));
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify({
+                status: 'ok',
+                pid: process.pid,
+                version,
+                instanceId,
+                activeSessions: Object.keys(ipcTransports).length,
+                queuedInitializations: initQueue.length,
+                sessionCapacity: ipcGuardConfig.maxSessions,
+            }));
             return;
         }
         // MCP endpoint
@@ -227,40 +364,54 @@ logDisclaimers();
                     json = body ? JSON.parse(body) : null;
                 }
                 catch {
-                    res.writeHead(400).end(JSON.stringify({
-                        jsonrpc: '2.0',
-                        error: { code: -32700, message: 'Parse error' },
-                        id: null,
-                    }));
+                    sendJsonRpcError(res, -32700, 'Parse error');
                     return;
                 }
                 let ipcTransport;
                 if (sessionId && ipcTransports[sessionId]) {
                     ipcTransport = ipcTransports[sessionId];
+                    touchIpcSession(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];
+                    try {
+                        await waitForInitCapacity();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : 'SERVER_BUSY_TIMEOUT';
+                        if (message === 'SERVER_QUEUE_FULL') {
+                            sendJsonRpcError(res, -32002, message, null, 503);
                         }
-                    };
-                    await server.connect(ipcTransport);
+                        else {
+                            sendJsonRpcError(res, -32001, message, null, 503);
+                        }
+                        return;
+                    }
+                    initializingCount++;
+                    try {
+                        ipcTransport = new StreamableHTTPServerTransport({
+                            sessionIdGenerator: () => randomUUID(),
+                            onsessioninitialized: newSessionId => {
+                                ipcTransports[newSessionId] = ipcTransport;
+                                touchIpcSession(newSessionId);
+                            },
+                            onsessionclosed: closedSessionId => {
+                                cleanupIpcSession(closedSessionId);
+                            },
+                        });
+                        ipcTransport.onclose = () => {
+                            if (ipcTransport?.sessionId) {
+                                cleanupIpcSession(ipcTransport.sessionId);
+                            }
+                        };
+                        await server.connect(ipcTransport);
+                    }
+                    finally {
+                        initializingCount = Math.max(0, initializingCount - 1);
+                        drainInitQueue();
+                    }
                 }
                 else {
-                    res.writeHead(400).end(JSON.stringify({
-                        jsonrpc: '2.0',
-                        error: {
-                            code: -32000,
-                            message: 'Bad Request: No valid session ID provided',
-                        },
-                        id: null,
-                    }));
+                    sendJsonRpcError(res, -32000, 'Bad Request: No valid session ID provided');
                     return;
                 }
                 try {
@@ -288,8 +439,12 @@ logDisclaimers();
                 res.writeHead(400).end('Invalid or missing session ID');
                 return;
             }
+            touchIpcSession(sessionId);
             try {
                 await ipcTransports[sessionId].handleRequest(req, res);
+                if (req.method === 'DELETE') {
+                    cleanupIpcSession(sessionId);
+                }
             }
             catch (error) {
                 if (!res.headersSent) {

package/build/src/process-lock.js

@@ -133,6 +133,30 @@ async function handleExistingLock() {
     logger(`[process-lock] Primary is alive (pid=${info.pid}, port=${info.port}). Cannot acquire lock.`);
     return false;
 }
+/**
+ * Try to acquire lock without throwing on failure.
+ * Returns true if lock acquired, false if another process holds it.
+ * Used by the retry-based startup loop in main.ts.
+ */
+export async function tryAcquireLockSafe(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 true;
+    }
+    const canRetry = await handleExistingLock();
+    if (!canRetry) {
+        return false;
+    }
+    const fd2 = tryCreateLock(port, instanceId);
+    if (fd2 !== null) {
+        lockFd = fd2;
+        logger(`[process-lock] Lock acquired after cleanup (pid=${process.pid}, port=${port})`);
+        return true;
+    }
+    return false;
+}
 /**
  * Acquire an exclusive process lock. Call once at startup for Primary mode.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "MCP server bridging Chrome extension and AI assistants (ChatGPT, Gemini). Extension-only mode - no Puppeteer.",
   "type": "module",
   "bin": "./scripts/cli.mjs",

package/scripts/cli.mjs

@@ -2,48 +2,24 @@
 /**
  * CLI Entry Point for chrome-ai-bridge
  *
- * This is the entry point when users run:
- *   npx chrome-ai-bridge
- *   chrome-ai-bridge (if globally installed)
- *
- * Launches the MCP server with browser globals mock:
- * - Loads browser-globals-mock.mjs BEFORE main.js
- * - Ensures chrome-devtools-frontend modules work in Node.js
- * - Simple execution: no wrapper, no hot-reload
+ * This entrypoint runs the MCP server in-process to avoid spawning an extra
+ * wrapper process per client (important for multi-pane usage).
  */
 
-import {spawn} from 'node:child_process';
-import process from 'node:process';
-import {fileURLToPath} from 'node:url';
 import path from 'node:path';
+import process from 'node:process';
+import {fileURLToPath, pathToFileURL} from 'node:url';
 
-// Resolve paths
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const mockPath = path.join(__dirname, 'browser-globals-mock.mjs');
 const mainPath = path.join(__dirname, '..', 'build', 'src', 'main.js');
 
-// Launch MCP server with --import flag
-const child = spawn(
-  process.execPath,
-  [
-    '--import',
-    mockPath,
-    mainPath,
-    ...process.argv.slice(2), // Forward CLI arguments
-  ],
-  {
-    stdio: 'inherit',
-    env: process.env,
-  },
-);
-
-child.on('exit', (code, signal) => {
-  if (signal) {
-    process.exit(1);
-  }
-  process.exit(code ?? 0);
-});
-
-// Forward signals
-process.on('SIGTERM', () => child?.kill('SIGTERM'));
-process.on('SIGINT', () => child?.kill('SIGINT'));
+try {
+  // Ensure browser globals are defined before loading main server modules.
+  await import(pathToFileURL(mockPath).href);
+  await import(pathToFileURL(mainPath).href);
+} catch (error) {
+  const message = error instanceof Error ? error.stack || error.message : String(error);
+  console.error(`[cli] Failed to start chrome-ai-bridge: ${message}`);
+  process.exit(1);
+}