chrome-ai-bridge 2.0.19 → 2.3.0

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.0.19",
+  "version": "2.3.0",
   "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",