chrome-ai-bridge 2.3.2 → 2.3.3

package/build/src/config.js

@@ -62,3 +62,26 @@ export function getSessionConfig() {
         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,7 +32,7 @@ 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 { 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() {
@@ -64,8 +65,33 @@ 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;
+    }
+}
+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));
+}
+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);
@@ -225,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();
@@ -233,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
@@ -261,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 {
@@ -322,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "2.3.2",
+  "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);
+}