chrome-ai-bridge 2.3.7 → 2.3.9

package/build/src/config.js

@@ -82,12 +82,12 @@ export function getIpcGuardConfig() {
         reservedInitSlots: raw.reservedInitSlots >= 0 ? Math.floor(raw.reservedInitSlots) : 2,
         maxQueue: raw.maxQueue > 0 ? Math.floor(raw.maxQueue) : 64,
         queueWaitTimeoutMs: raw.queueWaitTimeoutMs > 0 ? Math.floor(raw.queueWaitTimeoutMs) : 45_000,
-        sessionIdleMs: raw.sessionIdleMs > 0 ? Math.floor(raw.sessionIdleMs) : 120_000,
+        sessionIdleMs: raw.sessionIdleMs >= 0 ? Math.floor(raw.sessionIdleMs) : 1_800_000,
         startupDelayJitterMs: raw.startupDelayJitterMs > 0 ? Math.floor(raw.startupDelayJitterMs) : 1_500,
         startupProcessThreshold: raw.startupProcessThreshold > 0
             ? Math.floor(raw.startupProcessThreshold)
             : 8,
-        primaryIdleMs: raw.primaryIdleMs > 0 ? Math.floor(raw.primaryIdleMs) : 300_000,
+        primaryIdleMs: raw.primaryIdleMs >= 0 ? Math.floor(raw.primaryIdleMs) : 0,
         execMaxConcurrency: raw.execMaxConcurrency > 0 ? Math.floor(raw.execMaxConcurrency) : 3,
     };
 }

package/build/src/extension/relay-server.js

@@ -269,7 +269,7 @@ export class RelayServer extends EventEmitter {
      * Extension polls this endpoint when user clicks the extension icon.
      */
     async startDiscoveryServer(options = {}) {
-        const ports = [8765, 8766, 8767, 8768, 8769, 8770, 8771, 8772, 8773, 8774, 8775];
+        const ports = [38765, 38766, 38767, 38768, 38769, 38770, 38771, 38772, 38773, 38774, 38775];
         const wsUrl = this.getConnectionURL();
         for (const port of ports) {
             const started = await new Promise((resolve) => {

package/build/src/fast-cdp/extension-raw.js

@@ -5,6 +5,7 @@ import { RelayServer } from '../extension/relay-server.js';
 import { logRelay, logExtension, logInfo, logError } from './mcp-logger.js';
 // Stable extension ID (from manifest.json key)
 const EXTENSION_ID = 'ibjplbopgmcacpmfpnaeoloepdhenlbm';
+const ENABLE_WAKE_CONNECT_PAGE = process.env.CAI_ENABLE_WAKE_CONNECT_PAGE !== '0';
 /**
  * Get Chrome executable path for current platform
  */
@@ -91,6 +92,22 @@ function spawnChromeWithConnectUrl(connectUrl) {
         return false;
     }
 }
+function buildConnectUrl(options) {
+    const params = new URLSearchParams();
+    params.set('mcpRelayUrl', options.wsUrl);
+    params.set('sessionId', options.sessionId);
+    if (options.tabUrl)
+        params.set('tabUrl', options.tabUrl);
+    if (typeof options.tabId === 'number')
+        params.set('tabId', String(options.tabId));
+    if (options.newTab)
+        params.set('newTab', 'true');
+    if (options.allowTabTakeover)
+        params.set('allowTabTakeover', 'true');
+    if (options.auto)
+        params.set('auto', 'true');
+    return `chrome-extension://${EXTENSION_ID}/ui/connect.html?${params.toString()}`;
+}
 export async function connectViaExtensionRaw(options) {
     const startTime = Date.now();
     logInfo('extension-raw', 'connectViaExtensionRaw called', {
@@ -112,6 +129,15 @@ export async function connectViaExtensionRaw(options) {
     await relay.start();
     const wsUrl = relay.getConnectionURL();
     const sessionId = relay.getSessionId();
+    const connectUrl = buildConnectUrl({
+        wsUrl,
+        sessionId,
+        tabUrl: options.tabUrl,
+        tabId: options.tabId,
+        newTab: options.newTab,
+        allowTabTakeover: options.allowTabTakeover,
+        auto: true,
+    });
     logRelay('started', { wsUrl });
     console.error(`[fast-cdp] Relay URL: ${wsUrl} (session=${sessionId})`);
     // Save relay info for reload-extension.mjs (after discovery server starts)
@@ -140,14 +166,14 @@ export async function connectViaExtensionRaw(options) {
     }
     else {
         // Fallback: show manual URL
-        const connectUrl = `chrome-extension://${EXTENSION_ID}/ui/connect.html?mcpRelayUrl=${encodeURIComponent(wsUrl)}&sessionId=${encodeURIComponent(sessionId)}`;
         logError('extension-raw', 'Discovery server failed', { connectUrl });
         console.error(`[fast-cdp] Discovery server failed. Please open manually:`);
         console.error(`[fast-cdp]   ${connectUrl}`);
     }
     try {
         const actualTimeout = options.timeoutMs ?? 10000;
-        const softTimeout = Math.min(5000, Math.floor(actualTimeout * 0.5));
+        const softTimeout = Math.max(1200, Math.min(3000, Math.floor(actualTimeout * 0.3)));
+        let wakeAttempted = false;
         logExtension('waiting', { timeoutMs: actualTimeout });
         await new Promise((resolve, reject) => {
             let softTimedOut = false;
@@ -157,6 +183,17 @@ export async function connectViaExtensionRaw(options) {
                     waitedMs: softTimeout,
                     timeoutMs: actualTimeout,
                 });
+                if (ENABLE_WAKE_CONNECT_PAGE && !wakeAttempted) {
+                    wakeAttempted = true;
+                    const spawned = spawnChromeWithConnectUrl(connectUrl);
+                    logInfo('extension-raw', 'Wake connect page attempt', {
+                        attempted: true,
+                        spawned,
+                    });
+                    if (spawned) {
+                        console.error('[fast-cdp] Wake attempt: opened connect page in Chrome');
+                    }
+                }
             }, softTimeout);
             softTimer.unref();
             const timeout = setTimeout(() => {

package/build/src/fast-cdp/fast-chat.js

@@ -49,8 +49,21 @@ function setClientForAgent(kind, client, relay) {
         conn.geminiRelay = relay;
     }
 }
-const CONNECT_REUSE_TIMEOUT_MS = Number(process.env.MCP_CONNECT_REUSE_TIMEOUT_MS || '7000');
-const CONNECT_NEWTAB_TIMEOUT_MS = Number(process.env.MCP_CONNECT_NEWTAB_TIMEOUT_MS || '12000');
+const CONNECT_REUSE_TIMEOUT_MS = Number(process.env.MCP_CONNECT_REUSE_TIMEOUT_MS || '12000');
+const CONNECT_NEWTAB_TIMEOUT_MS = Number(process.env.MCP_CONNECT_NEWTAB_TIMEOUT_MS || '20000');
+const MCP_TOOL_BUDGET_MS = Number(process.env.CAI_MCP_TOOL_BUDGET_MS || '50000');
+const RESPONSE_WAIT_MAX_MS = Number(process.env.CAI_RESPONSE_WAIT_MAX_MS || '40000');
+const BUDGET_RESERVE_MS = Number(process.env.CAI_MCP_BUDGET_RESERVE_MS || '3000');
+function getRemainingBudgetMs(startMs) {
+    return MCP_TOOL_BUDGET_MS - (nowMs() - startMs) - BUDGET_RESERVE_MS;
+}
+function getResponseWaitBudgetMs(startMs, ceilingMs, stage) {
+    const remaining = getRemainingBudgetMs(startMs);
+    if (remaining <= 1000) {
+        throw new Error(`MCP_TOOL_BUDGET_EXCEEDED: stage=${stage} budgetMs=${MCP_TOOL_BUDGET_MS} reserveMs=${BUDGET_RESERVE_MS}`);
+    }
+    return Math.max(1000, Math.min(ceilingMs, remaining));
+}
 function nowMs() {
     return Date.now();
 }
@@ -994,9 +1007,8 @@ async function askChatGPTFastInternal(question, debug) {
     }
     const tWaitResp = nowMs();
     console.error('[ChatGPT] Waiting for response (using stop button detection)...');
-    // 新方式: ポーリングで状態を監視（診断ログ付き）
-    // 長い応答に対応するため8分（480秒）に設定
-    const maxWaitMs = 480000;
+    // 60秒 caller deadline を超えないよう、残り予算内で待機する。
+    const maxWaitMs = getResponseWaitBudgetMs(t0, RESPONSE_WAIT_MAX_MS, 'chatgpt-response');
     const pollIntervalMs = 1000;
     const startWait = Date.now();
     let lastLoggedState = '';
@@ -1350,7 +1362,8 @@ async function askChatGPTFastInternal(question, debug) {
         })()
       `);
         console.error(`[ChatGPT] Timeout - final state: ${JSON.stringify(finalState)}`);
-        throw new Error(`Timed out waiting for ChatGPT response (8min). Final state: ${JSON.stringify(finalState)}`);
+        await resetConnection('chatgpt');
+        throw new Error(`Timed out waiting for ChatGPT response (${maxWaitMs}ms). Final state: ${JSON.stringify(finalState)}`);
     }
     // ChatGPT 5.2 Thinking モデル対応:
     // 回答が「思考」として折りたたまれている場合は展開してからテキストを取得
@@ -1388,7 +1401,7 @@ async function askChatGPTFastInternal(question, debug) {
     // 回答完了後、DOM安定化のための追加待機
     // ChatGPT Thinkingモードでは、停止ボタン消失後も最終回答がレンダリングされるまで遅延がある
     // 回答テキストが存在するまでポーリングで待機
-    const maxWaitForText = 120000; // 最大120秒（Thinkingモード対応：長い思考の後の回答レンダリングを待機）
+    const maxWaitForText = getResponseWaitBudgetMs(t0, 15000, 'chatgpt-finalize');
     const pollInterval = 200;
     const waitStart = Date.now();
     let hasResponseText = false;
@@ -2065,7 +2078,8 @@ async function askChatGPTViaDriver(question, debug) {
     timings.sendMs = nowMs() - tSend;
     // 応答待機
     const tWaitResp = nowMs();
-    await driver.waitForResponse({ maxWaitMs: 480000 });
+    const driverWaitBudgetMs = getResponseWaitBudgetMs(t0, RESPONSE_WAIT_MAX_MS, 'chatgpt-driver-response');
+    await driver.waitForResponse({ maxWaitMs: driverWaitBudgetMs });
     timings.waitResponseMs = nowMs() - tWaitResp;
     // 応答抽出
     const extractResult = await driver.extractResponse({ debug });
@@ -2132,7 +2146,8 @@ async function askGeminiViaDriver(question, debug) {
     timings.sendMs = nowMs() - tSend;
     // 応答待機
     const tWaitResp = nowMs();
-    await driver.waitForResponse({ maxWaitMs: 480000 });
+    const driverWaitBudgetMs = getResponseWaitBudgetMs(t0, RESPONSE_WAIT_MAX_MS, 'gemini-driver-response');
+    await driver.waitForResponse({ maxWaitMs: driverWaitBudgetMs });
     timings.waitResponseMs = nowMs() - tWaitResp;
     // 応答抽出
     const extractResult = await driver.extractResponse({ debug });
@@ -2661,8 +2676,7 @@ async function askGeminiFastInternal(question, debug) {
     const tWaitResp = nowMs();
     console.error('[Gemini] Waiting for response completion (polling with diagnostics)...');
     // ChatGPT側と同様のポーリングループで応答完了を検出
-    // 長い応答に対応するため8分（480秒）に設定
-    const maxWaitMs = 480000;
+    const maxWaitMs = getResponseWaitBudgetMs(t0, RESPONSE_WAIT_MAX_MS, 'gemini-response');
     const pollIntervalMs = 1000;
     const startWait = Date.now();
     let lastLoggedState = '';
@@ -2859,7 +2873,8 @@ async function askGeminiFastInternal(question, debug) {
       })()
     `);
         console.error(`[Gemini] Timeout - final state: ${JSON.stringify(finalState)}`);
-        throw new Error(`Timed out waiting for Gemini response (8min). sawStopButton=${sawStopButton}, textStableCount=${textStableCount}. Final state: ${JSON.stringify(finalState)}`);
+        await resetConnection('gemini');
+        throw new Error(`Timed out waiting for Gemini response (${maxWaitMs}ms). sawStopButton=${sawStopButton}, textStableCount=${textStableCount}. Final state: ${JSON.stringify(finalState)}`);
     }
     // 重要: タブをフォアグラウンドに持ってくる（バックグラウンドタブ対策）
     // GeminiもChatGPTと同様、バックグラウンドタブではDOMの状態が正しく取得できない

package/build/src/main.js

@@ -33,7 +33,7 @@ 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 { getIpcGuardConfig, getSessionConfig, IPC_CONFIG } from './config.js';
-import { releaseLock, tryAcquireLockSafe, checkExistingPrimary, updateLockPort } from './process-lock.js';
+import { releaseLock, tryAcquireLockSafe, checkExistingPrimary, updateLockPort, terminatePrimaryProcess, getLockNamespace, cleanupOrphanBridgeProcesses, } from './process-lock.js';
 import { checkPrimaryHealth, startProxyMode } from './stdio-http-proxy.js';
 function readPackageJson() {
     const currentDir = import.meta.dirname;
@@ -54,6 +54,7 @@ const version = readPackageJson().version ?? 'unknown';
 export const args = parseArguments(version);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 logger(`Starting Chrome AI Bridge v${version} (Extension-only mode)`);
+logger(`[main] Runtime lock namespace: ${getLockNamespace()}`);
 // Initialize agent ID for Agent Teams support
 const agentId = generateAgentId();
 setAgentId(agentId);
@@ -65,9 +66,11 @@ const MAX_STARTUP_ATTEMPTS = 5;
 const BASE_DELAY_MS = 300;
 const HEALTH_CHECK_RETRIES = 3;
 const HEALTH_CHECK_INTERVAL_MS = 500;
+const PRIMARY_SELF_HEAL_MIN_AGE_MS = Number(process.env.CAI_PRIMARY_SELF_HEAL_MIN_AGE_MS || '20000');
 const ipcGuardConfig = getIpcGuardConfig();
 const instanceId = randomUUID();
 let becamePrimary = false;
+let attemptedPrimarySelfHeal = false;
 let stdinClosed = false;
 let getActiveIpcSessionCount = () => 0;
 function countLocalBridgeInstances() {
@@ -116,6 +119,29 @@ for (let attempt = 0; attempt < MAX_STARTUP_ATTEMPTS; attempt++) {
             }
         }
         logger(`[main] Primary (port=${existingPrimary.port}) not healthy after ${HEALTH_CHECK_RETRIES} retries.`);
+        const parsedStartedAt = existingPrimary.startedAt
+            ? Date.parse(existingPrimary.startedAt)
+            : NaN;
+        const primaryAgeMs = Number.isFinite(parsedStartedAt)
+            ? Math.max(0, Date.now() - parsedStartedAt)
+            : null;
+        if (!attemptedPrimarySelfHeal &&
+            existingPrimary.pid > 0 &&
+            (primaryAgeMs === null || primaryAgeMs >= PRIMARY_SELF_HEAL_MIN_AGE_MS)) {
+            attemptedPrimarySelfHeal = true;
+            logger(`[main] Attempting self-heal for unhealthy primary pid=${existingPrimary.pid} ageMs=${primaryAgeMs ?? 'unknown'}.`);
+            const terminated = await terminatePrimaryProcess(existingPrimary.pid);
+            if (terminated) {
+                logger('[main] Self-heal terminated unhealthy primary. Retrying startup immediately.');
+                continue;
+            }
+            logger('[main] Self-heal could not terminate unhealthy primary.');
+        }
+        else if (!attemptedPrimarySelfHeal &&
+            primaryAgeMs !== null &&
+            primaryAgeMs < PRIMARY_SELF_HEAL_MIN_AGE_MS) {
+            logger(`[main] Primary is unhealthy but still young (ageMs=${primaryAgeMs} < ${PRIMARY_SELF_HEAL_MIN_AGE_MS}). Skipping self-heal this round.`);
+        }
     }
     // 3. Neither Primary nor Proxy — backoff with jitter and retry
     if (attempt < MAX_STARTUP_ATTEMPTS - 1) {
@@ -173,6 +199,37 @@ Make sure the chrome-ai-bridge extension is installed and Chrome is running.
 Available tools: ask_chatgpt_web, ask_gemini_web, ask_chatgpt_gemini_web, take_cdp_snapshot, get_page_dom, ask_gemini_image`);
 };
 const toolMutex = new Mutex(ipcGuardConfig.execMaxConcurrency);
+const TOOL_SELF_CLEANUP_ENABLED = process.env.CAI_TOOL_SELF_CLEANUP_ENABLED !== '0';
+const TOOL_SELF_CLEANUP_INTERVAL_MS = Math.max(5000, Number(process.env.CAI_TOOL_SELF_CLEANUP_INTERVAL_MS || '60000'));
+let lastToolSelfCleanupAt = 0;
+let toolSelfCleanupInFlight = null;
+async function maybeRunToolSelfCleanup() {
+    if (!TOOL_SELF_CLEANUP_ENABLED) {
+        return;
+    }
+    const now = Date.now();
+    if (now - lastToolSelfCleanupAt < TOOL_SELF_CLEANUP_INTERVAL_MS) {
+        return;
+    }
+    if (toolSelfCleanupInFlight) {
+        await toolSelfCleanupInFlight;
+        return;
+    }
+    lastToolSelfCleanupAt = now;
+    toolSelfCleanupInFlight = (async () => {
+        const cleaned = await cleanupOrphanBridgeProcesses();
+        if (cleaned > 0) {
+            logger(`[main] Tool-triggered orphan cleanup removed ${cleaned} process(es).`);
+        }
+    })()
+        .catch(error => {
+        logger(`[main] Tool-triggered orphan cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    })
+        .finally(() => {
+        toolSelfCleanupInFlight = null;
+    });
+    await toolSelfCleanupInFlight;
+}
 function registerTool(tool) {
     server.registerTool(tool.name, {
         description: tool.description,
@@ -180,6 +237,7 @@ function registerTool(tool) {
         annotations: tool.annotations,
     }, async (params) => {
         touchPrimaryActivity();
+        await maybeRunToolSelfCleanup();
         const guard = await toolMutex.acquire();
         try {
             logger(`${tool.name} request: ${JSON.stringify(params, null, '  ')}`);
@@ -315,26 +373,31 @@ logDisclaimers();
             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();
+    if (ipcGuardConfig.sessionIdleMs > 0) {
+        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;
             }
-            catch {
-                // Ignore transport close errors and continue cleanup.
+            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);
             }
-            cleanupIpcSession(staleSessionId);
-        }
-    }, Math.max(10_000, Math.min(60_000, Math.floor(ipcGuardConfig.sessionIdleMs / 2))));
-    idleCleanupTimer.unref();
+        }, Math.max(10_000, Math.min(60_000, Math.floor(ipcGuardConfig.sessionIdleMs / 2))));
+        idleCleanupTimer.unref();
+    }
+    else {
+        logger('[ipc] Idle session cleanup is disabled (CAI_IPC_SESSION_IDLE_MS=0).');
+    }
     const ipcServer = http.createServer(async (req, res) => {
         if (!req.url || !req.method) {
             res.writeHead(400).end();
@@ -347,6 +410,7 @@ logDisclaimers();
                 status: 'ok',
                 pid: process.pid,
                 version,
+                namespace: getLockNamespace(),
                 instanceId,
                 activeSessions: getActiveSessionCount(),
                 queuedInitializations: initQueue.length,
@@ -504,15 +568,20 @@ logDisclaimers();
     });
     ipcServer.listen(IPC_CONFIG.port, IPC_CONFIG.host, onListening);
     // Primary idle auto-exit: exit when no activity and no active IPC sessions
-    const primaryIdleCheckTimer = setInterval(() => {
-        const activeSessionCount = getActiveSessionCount();
-        if (Date.now() - primaryLastActivityAt > ipcGuardConfig.primaryIdleMs &&
-            activeSessionCount === 0) {
-            logger(`[main] Primary idle for ${Math.round((Date.now() - primaryLastActivityAt) / 1000)}s with 0 active sessions. Auto-exiting.`);
-            shutdown('idle timeout');
-        }
-    }, 30_000);
-    primaryIdleCheckTimer.unref();
+    if (ipcGuardConfig.primaryIdleMs > 0) {
+        const primaryIdleCheckTimer = setInterval(() => {
+            const activeSessionCount = getActiveSessionCount();
+            if (Date.now() - primaryLastActivityAt > ipcGuardConfig.primaryIdleMs &&
+                activeSessionCount === 0) {
+                logger(`[main] Primary idle for ${Math.round((Date.now() - primaryLastActivityAt) / 1000)}s with 0 active sessions. Auto-exiting.`);
+                shutdown('idle timeout');
+            }
+        }, 30_000);
+        primaryIdleCheckTimer.unref();
+    }
+    else {
+        logger('[main] Primary idle auto-exit is disabled (CAI_PRIMARY_IDLE_MS=0).');
+    }
 }
 // Graceful shutdown handler with timeout
 // Based on review: タイムアウト必須、強制終了タイマー必要

package/build/src/process-lock.js

@@ -10,7 +10,10 @@ 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');
+import { getRuntimeNamespace } from './runtime-scope.js';
+const RUNTIME_NAMESPACE = getRuntimeNamespace();
+const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..');
+const LOCK_DIR = path.join(os.homedir(), '.cache', 'chrome-ai-bridge', RUNTIME_NAMESPACE);
 const LOCK_FILE = path.join(LOCK_DIR, 'mcp.lock');
 let lockFd = null;
 function isProcessAlive(pid) {
@@ -25,6 +28,23 @@ function isProcessAlive(pid) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+function collectDescendants(rows, rootPid) {
+    const descendants = new Set();
+    const stack = [rootPid];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (typeof current !== 'number') {
+            continue;
+        }
+        for (const row of rows) {
+            if (row.ppid === current && !descendants.has(row.pid)) {
+                descendants.add(row.pid);
+                stack.push(row.pid);
+            }
+        }
+    }
+    return descendants;
+}
 /**
  * Read lock file content. Supports both JSON (new) and plain PID (legacy).
  */
@@ -69,7 +89,13 @@ export function checkExistingPrimary() {
         logger(`[process-lock] Stale lock (pid=${info.pid}, not running).`);
         return null;
     }
-    return { alive: true, port: info.port, instanceId: info.instanceId };
+    return {
+        pid: info.pid,
+        alive: true,
+        port: info.port,
+        instanceId: info.instanceId,
+        startedAt: info.startedAt,
+    };
 }
 /**
  * Try to create lock file exclusively (wx flag).
@@ -225,6 +251,139 @@ export function releaseLock() {
     catch { /* ignore */ }
     logger('[process-lock] Lock released.');
 }
+/**
+ * Best-effort termination of a potentially unhealthy primary.
+ * Returns true if the process no longer exists after termination attempts.
+ */
+export async function terminatePrimaryProcess(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    if (!isProcessAlive(pid))
+        return true;
+    logger(`[process-lock] Attempting self-heal termination for pid=${pid} (SIGTERM).`);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        // Process may already be gone.
+    }
+    await sleep(1500);
+    if (!isProcessAlive(pid)) {
+        logger(`[process-lock] Self-heal termination succeeded for pid=${pid} after SIGTERM.`);
+        return true;
+    }
+    logger(`[process-lock] pid=${pid} still alive after SIGTERM. Sending SIGKILL.`);
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // ignore
+    }
+    await sleep(300);
+    const dead = !isProcessAlive(pid);
+    logger(dead
+        ? `[process-lock] Self-heal termination succeeded for pid=${pid} after SIGKILL.`
+        : `[process-lock] Self-heal termination failed for pid=${pid}.`);
+    return dead;
+}
+export function getLockNamespace() {
+    return RUNTIME_NAMESPACE;
+}
+export function getLockFilePath() {
+    return LOCK_FILE;
+}
+function listProcessRows() {
+    try {
+        const output = execFileSync('ps', ['-ax', '-o', 'pid=,ppid=,command='], {
+            encoding: 'utf-8',
+            timeout: 5000,
+        });
+        return output
+            .trim()
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean)
+            .map(line => {
+            const match = line.match(/^(\d+)\s+(\d+)\s+(.*)$/);
+            if (!match)
+                return null;
+            return {
+                pid: Number(match[1]),
+                ppid: Number(match[2]),
+                command: match[3],
+            };
+        })
+            .filter((row) => !!row && Number.isFinite(row.pid) && Number.isFinite(row.ppid));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Best-effort stale process sweep for this project path.
+ *
+ * Targets only orphaned bridge processes (ppid=1) for the same project root.
+ * The current process and lock-primary family are preserved.
+ *
+ * Returns number of terminated orphan processes.
+ */
+export async function cleanupOrphanBridgeProcesses(projectRootHint = PROJECT_ROOT) {
+    const rows = listProcessRows();
+    if (rows.length === 0)
+        return 0;
+    const normalizedRoot = path.resolve(projectRootHint);
+    const bridgeRows = rows.filter(row => row.command.includes(normalizedRoot) &&
+        (row.command.includes('/build/src/main.js') ||
+            row.command.includes('/scripts/cli.mjs')));
+    if (bridgeRows.length === 0)
+        return 0;
+    const protectedPids = new Set([process.pid, process.ppid]);
+    const lockInfo = readLockInfo();
+    if (lockInfo?.pid && isProcessAlive(lockInfo.pid)) {
+        protectedPids.add(lockInfo.pid);
+        for (const pid of collectDescendants(rows, lockInfo.pid)) {
+            protectedPids.add(pid);
+        }
+    }
+    else if (lockInfo?.pid && !isProcessAlive(lockInfo.pid)) {
+        try {
+            fs.unlinkSync(LOCK_FILE);
+            logger(`[process-lock] Removed stale lock during orphan sweep (pid=${lockInfo.pid}).`);
+        }
+        catch {
+            // ignore lock unlink failures
+        }
+    }
+    const targets = bridgeRows
+        .filter(row => row.ppid === 1)
+        .map(row => row.pid)
+        .filter(pid => !protectedPids.has(pid));
+    if (targets.length === 0)
+        return 0;
+    const dedupedTargets = Array.from(new Set(targets));
+    logger(`[process-lock] Cleaning orphan bridge process(es): ${dedupedTargets.join(', ')}`);
+    for (const pid of dedupedTargets) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // already gone
+        }
+    }
+    await sleep(500);
+    for (const pid of dedupedTargets) {
+        if (!isProcessAlive(pid)) {
+            continue;
+        }
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // ignore
+        }
+    }
+    return dedupedTargets.length;
+}
 /**
  * Kill all sibling chrome-ai-bridge processes (bulk cleanup).
  *

package/build/src/runtime-scope.js

@@ -0,0 +1,53 @@
+/**
+ * Runtime scope utilities.
+ *
+ * By default, scope is derived from the current git root (or cwd fallback),
+ * then hashed into a stable namespace.
+ * This isolates lock files between different projects using the same MCP.
+ */
+import crypto from 'node:crypto';
+import path from 'node:path';
+import process from 'node:process';
+import { execFileSync } from 'node:child_process';
+function detectScopePath() {
+    const envScope = String(process.env.CAI_SCOPE_PATH || '').trim();
+    if (envScope) {
+        return path.resolve(envScope);
+    }
+    try {
+        const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 1500,
+        }).trim();
+        if (gitRoot) {
+            return path.resolve(gitRoot);
+        }
+    }
+    catch {
+        // Not a git repo or git unavailable; fall back to cwd.
+    }
+    return path.resolve(process.cwd());
+}
+function normalizeNamespace(value) {
+    const trimmed = value.trim().toLowerCase();
+    const normalized = trimmed.replace(/[^a-z0-9._-]/g, '-').replace(/-+/g, '-');
+    return normalized.replace(/^-+|-+$/g, '');
+}
+export function getRuntimeNamespace() {
+    const envNamespace = String(process.env.CAI_NAMESPACE || '').trim();
+    if (envNamespace) {
+        const explicit = normalizeNamespace(envNamespace);
+        if (explicit) {
+            return explicit;
+        }
+    }
+    const scopePath = detectScopePath();
+    const hash = crypto
+        .createHash('sha1')
+        .update(scopePath)
+        .digest('hex')
+        .slice(0, 12);
+    return `scope-${hash}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "2.3.7",
+  "version": "2.3.9",
   "description": "MCP server bridging Chrome extension and AI assistants (ChatGPT, Gemini). Extension-only mode - no Puppeteer.",
   "type": "module",
   "bin": "./scripts/cli.mjs",
@@ -37,6 +37,9 @@
     "test:mcp:parallel": "npm run build && node scripts/test-mcp.mjs --parallel",
     "test:network": "npm run build && node scripts/test-network-intercept.mjs",
     "test": "npm run build:noext && node scripts/test-mcp.mjs --tools-only",
+    "discord:collect": "node scripts/discord-readonly-collector.mjs",
+    "discord:preflight": "node scripts/discord-readonly-preflight.mjs",
+    "discord:status": "node scripts/discord-readonly-status.mjs",
     "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"