wsl-chrome-bridge 0.2.0 → 0.3.0

package/dist/bridge-runner.js

@@ -1,206 +1,150 @@
 import { appendFileSync, createReadStream, createWriteStream, fstatSync, lstatSync, mkdirSync, readdirSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
 import { once } from "node:events";
 import { createServer } from "node:http";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { WebSocket, WebSocketServer } from "ws";
 import { buildWindowsChromeArgs, parseBrowserPathFromWsUrl, planBridgeLaunch } from "./bridge-options.js";
 import { resolveChromeCommand } from "./chrome-command.js";
 import { createPowerShellContext, destroyPowerShellContext, runPowerShellFile, writePowerShellScript } from "./powershell.js";
+import { getBridgePowerShellScripts } from "./bridge-powershell-scripts.js";
 const POLL_INTERVAL_MS = 400;
 const CHROME_READY_TIMEOUT_MS = 30_000;
-const LAUNCH_CHROME_PS = `
-param(
-  [string]$ChromePath,
-  [Parameter(ValueFromRemainingArguments = $true)]
-  [string[]]$ChromeArgs
-)
-$ErrorActionPreference = 'Stop'
-$ChromeArgs = $ChromeArgs | ForEach-Object { [Environment]::ExpandEnvironmentVariables($_) }
-$userDataArg = $ChromeArgs | Where-Object { $_ -like "--user-data-dir=*" } | Select-Object -First 1
-if ($null -ne $userDataArg) {
-  $userDataDir = $userDataArg.Substring(16)
-  $escaped = [Regex]::Escape($userDataDir)
-  $existing = Get-CimInstance Win32_Process -Filter "Name='chrome.exe'" | Where-Object {
-    $null -ne $_.CommandLine -and $_.CommandLine -match ("--user-data-dir(=|\\s+)" + $escaped)
-  }
-  foreach ($proc in $existing) {
-    Stop-Process -Id $proc.ProcessId -Force -ErrorAction SilentlyContinue
-  }
+const LARGE_CDP_STRING_BYTES = 16 * 1024;
+const MAX_TRACKED_REQUEST_METHODS = 100;
+const INTERNAL_CDP_REQUEST_ID_START = 900_000_000;
+const DISCONNECT_EVENT_BUFFER_LIMIT = 10;
+const DISCONNECT_EVENT_TIME_WINDOW_MS = 2_000;
+const IMPORTANT_CDP_METHODS = new Set([
+    // Target/session lifecycle (most common failure points for attach/detach/disconnect)
+    "Target.setDiscoverTargets",
+    "Target.getTargets",
+    "Target.getTargetInfo",
+    "Target.getDevToolsTarget",
+    "Target.setAutoAttach",
+    "Target.autoAttachRelated",
+    "Target.attachToTarget",
+    "Target.attachedToTarget",
+    "Target.detachFromTarget",
+    "Target.detachedFromTarget",
+    "Target.targetCreated",
+    "Target.targetInfoChanged",
+    "Target.targetDestroyed",
+    "Target.activateTarget",
+    "Target.createTarget",
+    "Target.closeTarget",
+    // Browser/page open-close lifecycle
+    "Browser.getVersion",
+    "Browser.close",
+    "Page.navigate",
+    "Page.frameStartedLoading",
+    // Disconnection/error signals
+    "Inspector.detached",
+    "Runtime.exceptionThrown",
+    "Network.loadingFailed"
+]);
+const IMPORTANT_EXCLUDED_METHODS = new Set([
+    // Common benign error during early-frame phases; noisy but usually not a disconnect root cause.
+    "Storage.getStorageKey"
+]);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
-$proc = Start-Process -FilePath $ChromePath -ArgumentList $ChromeArgs -PassThru
-Write-Output $proc.Id
-`;
-const GET_VERSION_PS = `
-param([int]$Port)
-$ErrorActionPreference = 'Stop'
-$uri = "http://127.0.0.1:$Port/json/version"
-try {
-  $json = Invoke-RestMethod -UseBasicParsing -Uri $uri -TimeoutSec 2
-  if ($null -eq $json) { exit 1 }
-  $raw = $json | ConvertTo-Json -Compress -Depth 12
-  Write-Output $raw
-  exit 0
-} catch {
-  exit 1
+const WEAK_DISCONNECT_SIGNALS = new Set([
+    "Inspector.detached",
+    "Target.detachedFromTarget"
+]);
+const STRONG_DISCONNECT_SIGNALS = new Set([
+    "ConnectionClosedPrematurely",
+    "READER_CLOSE"
+]);
+function isWeakDisconnectSignal(signal) {
+    return signal === "Inspector.detached" || signal === "Target.detachedFromTarget";
 }
-`;
-const RESOLVE_PORT_PS = `
-param(
-  [int]$RequestedPort,
-  [string]$Mode
-)
-$ErrorActionPreference = 'Stop'
-
-function Test-PortAvailable {
-  param([int]$Port)
-  try {
-    $listener = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, $Port)
-    $listener.Start()
-    $listener.Stop()
-    return $true
-  } catch {
-    return $false
-  }
+function isStrongDisconnectSignal(signal) {
+    return signal === "ConnectionClosedPrematurely" || signal === "READER_CLOSE";
 }
-
-function Get-RandomFreePort {
-  $listener = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, 0)
-  $listener.Start()
-  $allocated = ([System.Net.IPEndPoint]$listener.LocalEndpoint).Port
-  $listener.Stop()
-  return $allocated
+function cdpKindLabel(kind) {
+    switch (kind) {
+        case "request":
+            return "Request";
+        case "response":
+            return "Response";
+        case "event":
+            return "Event";
+        case "invalid-json":
+            return "InvalidJson";
+        case "unknown":
+            return "Unknown";
+    }
 }
-
-if ($Mode -eq "fixed") {
-  if (-not (Test-PortAvailable -Port $RequestedPort)) {
-    Write-Error "Port $RequestedPort is already in use on Windows."
-    exit 2
-  }
-  Write-Output $RequestedPort
-  exit 0
+function asObject(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
 }
-
-if ($Mode -eq "random") {
-  if ($RequestedPort -gt 0 -and (Test-PortAvailable -Port $RequestedPort)) {
-    Write-Output $RequestedPort
-    exit 0
-  }
-
-  for ($i = 0; $i -lt 50; $i++) {
-    $candidate = Get-RandomFreePort
-    if (Test-PortAvailable -Port $candidate) {
-      Write-Output $candidate
-      exit 0
+function pickFirstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
     }
-  }
-
-  Write-Error "Failed to allocate an available Windows debug port."
-  exit 3
+    return null;
 }
-
-Write-Error "Unsupported mode: $Mode"
-exit 4
-`;
-const STOP_PROCESS_PS = `
-param([int]$Pid)
-$ErrorActionPreference = 'SilentlyContinue'
-Stop-Process -Id $Pid -Force
-`;
-const RELAY_CSHARP = String.raw `
-using System;
-using System.IO;
-using System.Net.WebSockets;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-
-public class CDPRelay
-{
-    public static void Run(string wsUrl)
-    {
-        var ws = new ClientWebSocket();
-        ws.Options.KeepAliveInterval = TimeSpan.FromSeconds(30);
-        var cts = new CancellationTokenSource();
-        var token = cts.Token;
-
-        try
-        {
-            ws.ConnectAsync(new Uri(wsUrl), token).GetAwaiter().GetResult();
-            Console.Error.WriteLine("CONNECTED");
-            Console.Error.Flush();
-
-            var reader = Task.Run(() =>
-            {
-                var buf = new byte[4 * 1024 * 1024];
-                try
-                {
-                    while (ws.State == WebSocketState.Open && !token.IsCancellationRequested)
-                    {
-                        var sb = new StringBuilder();
-                        WebSocketReceiveResult recv;
-                        do
-                        {
-                            var seg = new ArraySegment<byte>(buf);
-                            recv = ws.ReceiveAsync(seg, token).GetAwaiter().GetResult();
-                            if (recv.MessageType == WebSocketMessageType.Close) return;
-                            sb.Append(Encoding.UTF8.GetString(buf, 0, recv.Count));
-                        } while (!recv.EndOfMessage);
-
-                        Console.Out.WriteLine(sb.ToString());
-                        Console.Out.Flush();
-                    }
-                }
-                catch (OperationCanceledException) { }
-                catch (Exception ex)
-                {
-                    Console.Error.WriteLine("READER_ERROR:" + ex.Message);
-                    Console.Error.Flush();
-                }
-            }, token);
-
-            string line;
-            while ((line = Console.In.ReadLine()) != null)
-            {
-                if (ws.State != WebSocketState.Open) break;
-                var bytes = Encoding.UTF8.GetBytes(line);
-                var seg = new ArraySegment<byte>(bytes);
-                ws.SendAsync(seg, WebSocketMessageType.Text, true, token).GetAwaiter().GetResult();
-            }
-
-            cts.Cancel();
-            reader.Wait(TimeSpan.FromSeconds(2));
+function parseRelayMessage(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        const id = typeof parsed.id === "number" || typeof parsed.id === "string" ? parsed.id : null;
+        const method = typeof parsed.method === "string" ? parsed.method : null;
+        const hasResult = Object.prototype.hasOwnProperty.call(parsed, "result");
+        const hasError = Object.prototype.hasOwnProperty.call(parsed, "error");
+        const paramsObj = asObject(parsed.params);
+        const resultObj = asObject(parsed.result);
+        const paramsTargetInfoObj = asObject(paramsObj?.targetInfo);
+        const resultTargetInfoObj = asObject(resultObj?.targetInfo);
+        const targetId = pickFirstString(parsed.targetId, paramsObj?.targetId, paramsTargetInfoObj?.targetId, resultObj?.targetId, resultTargetInfoObj?.targetId);
+        const browserContextId = pickFirstString(parsed.browserContextId, paramsObj?.browserContextId, paramsTargetInfoObj?.browserContextId, resultObj?.browserContextId, resultTargetInfoObj?.browserContextId);
+        const sessionId = pickFirstString(parsed.sessionId, paramsObj?.sessionId, resultObj?.sessionId);
+        if (method && id !== null) {
+            return { kind: "request", id, method, hasError: false, targetId, browserContextId, sessionId };
         }
-        catch (Exception ex)
-        {
-            Console.Error.WriteLine("FATAL:" + ex.Message);
-            Console.Error.Flush();
+        if (id !== null && (hasResult || hasError || !method)) {
+            return { kind: "response", id, method, hasError, targetId, browserContextId, sessionId };
         }
-        finally
-        {
-            if (ws.State == WebSocketState.Open)
-            {
-                try
-                {
-                    ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).GetAwaiter().GetResult();
-                }
-                catch { }
-            }
-            ws.Dispose();
+        if (method) {
+            return { kind: "event", id: null, method, hasError: false, targetId, browserContextId, sessionId };
         }
+        return { kind: "unknown", id, method, hasError, targetId, browserContextId, sessionId };
+    }
+    catch {
+        return {
+            kind: "invalid-json",
+            id: null,
+            method: null,
+            hasError: false,
+            targetId: null,
+            browserContextId: null,
+            sessionId: null
+        };
     }
 }
-`;
-const RELAY_PS = `
-param([string]$WsUrl)
-$ErrorActionPreference = 'Stop'
-Add-Type -TypeDefinition @'
-${RELAY_CSHARP}
-'@
-[CDPRelay]::Run($WsUrl)
-`;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+function toSafeRawTimestamp(iso) {
+    return iso.replaceAll(":", "-").replaceAll(".", "-");
+}
+function normalizeDebugLevel(raw) {
+    const value = raw?.trim().toLowerCase();
+    if (!value || value === "important" || value === "important-only") {
+        return "important";
+    }
+    if (value === "all" || value === "full") {
+        return "all";
+    }
+    return "important";
+}
+function requestKey(id, sessionId) {
+    return `${sessionId ?? "root"}::${String(id)}`;
 }
 function detectUpstreamHint(chromeArgs) {
     const hasPipeMode = chromeArgs.includes("--remote-debugging-pipe");
@@ -220,12 +164,22 @@ function collectBridgeEnvSnapshot(env) {
     return {
         WSL_CHROME_BRIDGE_DEBUG: env.WSL_CHROME_BRIDGE_DEBUG ?? null,
         WSL_CHROME_BRIDGE_DEBUG_FILE: env.WSL_CHROME_BRIDGE_DEBUG_FILE ?? null,
+        WSL_CHROME_BRIDGE_DEBUG_LEVEL: env.WSL_CHROME_BRIDGE_DEBUG_LEVEL ?? null,
+        WSL_CHROME_BRIDGE_DEBUG_RAW_DIR: env.WSL_CHROME_BRIDGE_DEBUG_RAW_DIR ?? null,
         WSL_CHROME_BRIDGE_REMOTE_DEBUG_PORT: env.WSL_CHROME_BRIDGE_REMOTE_DEBUG_PORT ?? null,
         WSL_CHROME_BRIDGE_EXECUTABLE_PATH: env.WSL_CHROME_BRIDGE_EXECUTABLE_PATH ?? null,
         WSL_CHROME_BRIDGE_USER_DATA_DIR: env.WSL_CHROME_BRIDGE_USER_DATA_DIR ?? null,
         DISPLAY: env.DISPLAY ?? null
     };
 }
+function hasRequestedHeadlessFlag(args) {
+    for (const arg of args) {
+        if (arg === "--headless" || arg.startsWith("--headless=")) {
+            return true;
+        }
+    }
+    return false;
+}
 function cleanupEmptyLocalUserDataDirArtifact(userDataDir, writeDebug) {
     if (!userDataDir) {
         return;
@@ -270,6 +224,104 @@ function hasPipeFds() {
         return false;
     }
 }
+function parseExistingChromeMatch(raw) {
+    try {
+        const value = JSON.parse(raw.trim());
+        if (value &&
+            Object.prototype.hasOwnProperty.call(value, "found") &&
+            value.found === false) {
+            return null;
+        }
+        const port = Number.parseInt(String(value.port), 10);
+        if (!Number.isFinite(port) || port < 1 || port > 65535) {
+            return null;
+        }
+        const pidRaw = value.pid;
+        const pid = typeof pidRaw === "number" && Number.isFinite(pidRaw)
+            ? Math.trunc(pidRaw)
+            : Number.parseInt(String(pidRaw), 10);
+        const headless = value.headless === true;
+        return {
+            port,
+            pid: Number.isFinite(pid) ? pid : null,
+            headless
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseRelayField(line, field) {
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(?:^|;)${escapedField}=([^;]*)`);
+    const match = line.match(pattern);
+    if (!match) {
+        return null;
+    }
+    return match[1] ?? null;
+}
+function detectStrongDisconnectSignalFromRelayLog(line) {
+    if (line.startsWith("READER_CLOSE:")) {
+        return "READER_CLOSE";
+    }
+    if (!line.startsWith("READER_ERROR:")) {
+        return null;
+    }
+    const payload = line.slice("READER_ERROR:".length);
+    const webSocketErrorCode = parseRelayField(payload, "webSocketErrorCode");
+    if (webSocketErrorCode === "ConnectionClosedPrematurely") {
+        return "ConnectionClosedPrematurely";
+    }
+    return null;
+}
+function detectWeakDisconnectSignalFromCdp(rendered) {
+    if (rendered.parsed.kind !== "event" || !rendered.canonicalMethod) {
+        return null;
+    }
+    if (rendered.canonicalMethod === "Inspector.detached") {
+        return "Inspector.detached";
+    }
+    if (rendered.canonicalMethod === "Target.detachedFromTarget") {
+        return "Target.detachedFromTarget";
+    }
+    return null;
+}
+function assessDisconnectSignals(signals, recentWeakEvents, disconnectAtMs, windowMs) {
+    let weakSignalSeen = false;
+    let strongSignalSeen = false;
+    for (const signal of signals) {
+        if (isWeakDisconnectSignal(signal) && WEAK_DISCONNECT_SIGNALS.has(signal)) {
+            weakSignalSeen = true;
+        }
+        if (isStrongDisconnectSignal(signal) && STRONG_DISCONNECT_SIGNALS.has(signal)) {
+            strongSignalSeen = true;
+        }
+    }
+    // We only treat weak disconnect events as actionable when they happen
+    // immediately before websocket interruption. This avoids stale-detach false positives.
+    const nearbyWeakEvents = [];
+    for (const event of recentWeakEvents) {
+        const deltaMs = disconnectAtMs - event.observedAtMs;
+        if (deltaMs < 0 || deltaMs > windowMs) {
+            continue;
+        }
+        nearbyWeakEvents.push({
+            signal: event.signal,
+            deltaMs,
+            rawJson: event.rawJson
+        });
+    }
+    const weakSignalWithinWindow = nearbyWeakEvents.length > 0;
+    return {
+        weakSignalSeen,
+        strongSignalSeen,
+        weakSignalWithinWindow,
+        chromeDisconnectedLikely: weakSignalWithinWindow && strongSignalSeen,
+        summary: Array.from(signals).join(",") || "none",
+        nearbyWeakEventCount: nearbyWeakEvents.length,
+        nearbyWeakEvents
+    };
+}
 async function startLocalDebugProxy(options) {
     const clients = new Set();
     const wsServer = new WebSocketServer({ noServer: true });
@@ -354,7 +406,14 @@ export function createBridgeRunner() {
         const env = process.env;
         const debugFileFromEnv = env.WSL_CHROME_BRIDGE_DEBUG_FILE?.trim() || null;
         let activeDebugFile = debugFileFromEnv;
+        let activeRawDebugDir = env.WSL_CHROME_BRIDGE_DEBUG_RAW_DIR?.trim() || null;
+        const debugLevel = normalizeDebugLevel(env.WSL_CHROME_BRIDGE_DEBUG_LEVEL);
         const debug = env.WSL_CHROME_BRIDGE_DEBUG === "1" || Boolean(activeDebugFile);
+        const requestMethodById = new Map();
+        let internalCdpRequestId = INTERNAL_CDP_REQUEST_ID_START;
+        const pendingInternalCdpRequests = new Map();
+        let lastRawTimestamp = "";
+        let sameTimestampSequence = 0;
         const writeDebug = (message) => {
             if (!debug) {
                 return;
@@ -371,6 +430,145 @@ export function createBridgeRunner() {
                 }
             }
         };
+        const writeRawPayload = (payload) => {
+            if (!activeRawDebugDir) {
+                return null;
+            }
+            try {
+                mkdirSync(activeRawDebugDir, { recursive: true });
+                const now = new Date();
+                const safeTimestamp = toSafeRawTimestamp(now.toISOString());
+                if (safeTimestamp === lastRawTimestamp) {
+                    sameTimestampSequence += 1;
+                }
+                else {
+                    lastRawTimestamp = safeTimestamp;
+                    sameTimestampSequence = 0;
+                }
+                const suffix = sameTimestampSequence === 0 ? "" : `-${String(sameTimestampSequence).padStart(4, "0")}`;
+                const fileName = `raw-${safeTimestamp}${suffix}.log`;
+                const path = join(activeRawDebugDir, fileName);
+                writeFileSync(path, payload, "utf8");
+                return path;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeDebug(`rawPayloadWriteFailed dir=${activeRawDebugDir} error=${message}`);
+                return null;
+            }
+        };
+        const writeDebugBlock = (header, jsonPayload) => {
+            if (!debug) {
+                return;
+            }
+            const timestamp = new Date().toISOString();
+            const body = typeof jsonPayload === "string" ? jsonPayload : JSON.stringify(jsonPayload);
+            const block = `[${timestamp}] ${header}\n${body}\n\n`;
+            process.stderr.write(`[wsl-chrome-bridge][debug] ${header}\n${body}\n`);
+            if (activeDebugFile) {
+                try {
+                    mkdirSync(dirname(activeDebugFile), { recursive: true });
+                    appendFileSync(activeDebugFile, block, "utf8");
+                }
+                catch {
+                    // keep running even if debug file write fails
+                }
+            }
+        };
+        const replaceLargeStringFields = (value, path) => {
+            if (typeof value === "string") {
+                if (Buffer.byteLength(value, "utf8") < LARGE_CDP_STRING_BYTES) {
+                    return value;
+                }
+                const rawPath = writeRawPayload(value);
+                if (!rawPath) {
+                    return value;
+                }
+                return {
+                    __rawDataPath: rawPath,
+                    __rawDataBytes: Buffer.byteLength(value, "utf8"),
+                    __replacedField: path
+                };
+            }
+            if (Array.isArray(value)) {
+                return value.map((item, index) => replaceLargeStringFields(item, `${path}[${index}]`));
+            }
+            if (value && typeof value === "object") {
+                const record = value;
+                const replaced = {};
+                for (const [key, child] of Object.entries(record)) {
+                    replaced[key] = replaceLargeStringFields(child, `${path}.${key}`);
+                }
+                return replaced;
+            }
+            return value;
+        };
+        const hopLabel = (hop) => {
+            switch (hop) {
+                case "upstream=>relay":
+                    return "upstream -> relay";
+                case "relay=>chrome":
+                    return "relay -> chrome";
+                case "chrome=>relay":
+                    return "chrome -> relay";
+                case "relay=>upstream":
+                    return "relay -> upstream";
+            }
+        };
+        const renderCdpMessage = (payload) => {
+            const parsed = parseRelayMessage(payload);
+            let canonicalMethod = parsed.method;
+            if (parsed.kind === "request" && parsed.id !== null && parsed.method) {
+                if (requestMethodById.size >= MAX_TRACKED_REQUEST_METHODS) {
+                    const oldest = requestMethodById.keys().next().value;
+                    if (oldest) {
+                        requestMethodById.delete(oldest);
+                    }
+                }
+                requestMethodById.set(requestKey(parsed.id, parsed.sessionId), parsed.method);
+            }
+            if (!canonicalMethod && parsed.kind === "response" && parsed.id !== null) {
+                const key = requestKey(parsed.id, parsed.sessionId);
+                canonicalMethod = requestMethodById.get(key) ?? null;
+                requestMethodById.delete(key);
+            }
+            const title = canonicalMethod ??
+                (parsed.kind === "response" && parsed.id !== null
+                    ? `id=${parsed.id}`
+                    : parsed.kind === "invalid-json"
+                        ? "InvalidJSON"
+                        : "UnknownMessage");
+            try {
+                const json = JSON.parse(payload);
+                const replaced = replaceLargeStringFields(json, "$");
+                if (replaced && typeof replaced === "object" && !Array.isArray(replaced)) {
+                    const asRecord = { ...replaced };
+                    delete asRecord.method;
+                    return { title, payload: asRecord, parsed, canonicalMethod };
+                }
+                return { title, payload: replaced, parsed, canonicalMethod };
+            }
+            catch {
+                return { title, payload, parsed, canonicalMethod };
+            }
+        };
+        const isImportantRenderedMessage = (rendered) => {
+            const method = rendered.canonicalMethod;
+            if (method && IMPORTANT_EXCLUDED_METHODS.has(method)) {
+                return false;
+            }
+            if (rendered.parsed.hasError) {
+                return true;
+            }
+            return method !== null && IMPORTANT_CDP_METHODS.has(method);
+        };
+        const writeCdpHopLog = (hop, rendered) => {
+            if (debugLevel === "important" && !isImportantRenderedMessage(rendered)) {
+                return;
+            }
+            const kind = cdpKindLabel(rendered.parsed.kind);
+            writeDebugBlock(`CDP(${hopLabel(hop)}) ${kind} ${rendered.title}`, rendered.payload);
+        };
         if (activeDebugFile) {
             try {
                 mkdirSync(dirname(activeDebugFile), { recursive: true });
@@ -404,9 +602,28 @@ export function createBridgeRunner() {
                 process.stderr.write(`[wsl-chrome-bridge] failed to create debug file: ${activeDebugFile}\n`);
             }
         }
+        if (!activeRawDebugDir && plan.bridgeDebugRawDir) {
+            activeRawDebugDir = plan.bridgeDebugRawDir;
+        }
+        if (activeRawDebugDir) {
+            try {
+                mkdirSync(activeRawDebugDir, { recursive: true });
+                writeDebug(`rawDebugDir enabled path=${activeRawDebugDir}`);
+            }
+            catch {
+                process.stderr.write(`[wsl-chrome-bridge] failed to create raw debug dir: ${activeRawDebugDir}\n`);
+                activeRawDebugDir = null;
+            }
+        }
+        else {
+            writeDebug("rawDebugDir disabled");
+        }
+        writeDebug(`debugLevel=${debugLevel}`);
         writeDebug(`argv=${JSON.stringify(chromeArgs)}`);
+        const requestedHeadlessMode = hasRequestedHeadlessFlag(plan.passthroughArgs);
         writeDebug(`launchPlan=${JSON.stringify({
             bridgeDebugFile: plan.bridgeDebugFile,
+            bridgeDebugRawDir: plan.bridgeDebugRawDir,
             bridgeChromeExecutablePath: plan.bridgeChromeExecutablePath,
             usePipeTransport: plan.usePipeTransport,
             userDataDir: plan.userDataDir,
@@ -416,6 +633,7 @@ export function createBridgeRunner() {
             localProxyPort: plan.localProxyPort,
             windowsDebugPort: plan.windowsDebugPort,
             windowsDebugPortSource: plan.windowsDebugPortSource,
+            requestedHeadlessMode,
             passthroughArgs: plan.passthroughArgs
         })}`);
         cleanupEmptyLocalUserDataDirArtifact(plan.userDataDir, writeDebug);
@@ -428,127 +646,189 @@ export function createBridgeRunner() {
         };
         const powerShell = createPowerShellContext(env);
         writeDebug(`powershellPath=${powerShell.powershellPath}`);
-        const launchScript = writePowerShellScript(powerShell, "launch-chrome.ps1", LAUNCH_CHROME_PS);
-        const getVersionScript = writePowerShellScript(powerShell, "get-version.ps1", GET_VERSION_PS);
-        const resolvePortScript = writePowerShellScript(powerShell, "resolve-port.ps1", RESOLVE_PORT_PS);
-        const stopProcessScript = writePowerShellScript(powerShell, "stop-process.ps1", STOP_PROCESS_PS);
-        const relayScript = writePowerShellScript(powerShell, "relay.ps1", RELAY_PS);
-        writeDebug(`scripts={launch:${launchScript.windowsPath},version:${getVersionScript.windowsPath},resolvePort:${resolvePortScript.windowsPath},stop:${stopProcessScript.windowsPath},relay:${relayScript.windowsPath}}`);
-        const resolvePortMode = plan.windowsDebugPortSource === "auto-random" ? "random" : "fixed";
-        const resolvePortResult = await runPowerShellFile(powerShell, resolvePortScript.windowsPath, [String(plan.windowsDebugPort), resolvePortMode], { timeoutMs: 8_000 });
-        if (resolvePortResult.code !== 0) {
-            writeDebug(`resolvePortFailed mode=${resolvePortMode} requested=${plan.windowsDebugPort} code=${resolvePortResult.code} stdout=${resolvePortResult.stdout.trim()} stderr=${resolvePortResult.stderr.trim()}`);
-            process.stderr.write("[wsl-chrome-bridge] failed to resolve an available Windows debug port: " +
-                `${resolvePortResult.stderr || resolvePortResult.stdout}\n`);
-            destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("resolvePortFailed");
-            return 1;
-        }
-        const resolvedWindowsDebugPort = Number.parseInt(resolvePortResult.stdout.trim(), 10);
-        if (!Number.isFinite(resolvedWindowsDebugPort)) {
-            writeDebug(`resolvePortParseFailed raw=${resolvePortResult.stdout.trim()} stderr=${resolvePortResult.stderr.trim()}`);
-            process.stderr.write("[wsl-chrome-bridge] failed to parse resolved Windows debug port from PowerShell output.\n");
-            destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("resolvePortParseFailed");
-            return 1;
-        }
-        writeDebug(`resolvedWindowsDebugPort=${resolvedWindowsDebugPort} source=${plan.windowsDebugPortSource} mode=${resolvePortMode}`);
-        const planWithResolvedPort = {
-            ...plan,
-            windowsDebugPort: resolvedWindowsDebugPort
-        };
-        const chromePath = resolveChromeCommand({
-            env,
-            bridgeChromeExecutablePath: plan.bridgeChromeExecutablePath
-        });
-        const windowsArgs = buildWindowsChromeArgs(planWithResolvedPort, env);
-        writeDebug(`chromePath=${chromePath}`);
-        writeDebug(`windowsArgs=${JSON.stringify(windowsArgs)}`);
-        const launchResult = await runPowerShellFile(powerShell, launchScript.windowsPath, [chromePath, ...windowsArgs], { timeoutMs: 15_000 });
-        if (launchResult.code !== 0) {
-            writeDebug(`launchFailed code=${launchResult.code} stdout=${launchResult.stdout} stderr=${launchResult.stderr}`);
-            process.stderr.write(`[wsl-chrome-bridge] failed to launch Windows Chrome: ${launchResult.stderr || launchResult.stdout}\n`);
+        const scripts = getBridgePowerShellScripts();
+        const launchScript = writePowerShellScript(powerShell, "launch-chrome.ps1", scripts.launchChrome);
+        const findExistingChromeScript = writePowerShellScript(powerShell, "find-existing-chrome.ps1", scripts.findExistingChrome);
+        const getVersionScript = writePowerShellScript(powerShell, "get-version.ps1", scripts.getVersion);
+        const resolvePortScript = writePowerShellScript(powerShell, "resolve-port.ps1", scripts.resolvePort);
+        const stopChromeScript = writePowerShellScript(powerShell, "stop-chrome-by-profile-port.ps1", scripts.stopChromeByProfilePort);
+        const relayScript = writePowerShellScript(powerShell, "relay.ps1", scripts.relay);
+        writeDebug(`scripts={launch:${launchScript.windowsPath},findExisting:${findExistingChromeScript.windowsPath},version:${getVersionScript.windowsPath},resolvePort:${resolvePortScript.windowsPath},stopChrome:${stopChromeScript.windowsPath},relay:${relayScript.windowsPath}}`);
+        const usePipeTransport = plan.usePipeTransport && hasPipeFds();
+        const useLocalProxyTransport = plan.localProxyPort !== null;
+        writeDebug(`transportMode requestedPipe=${plan.usePipeTransport} pipe=${usePipeTransport} localProxy=${useLocalProxyTransport} localProxyPort=${plan.localProxyPort ?? "none"}`);
+        if (plan.usePipeTransport && !usePipeTransport) {
+            process.stderr.write("[wsl-chrome-bridge] --remote-debugging-pipe was requested but OS pipe fds (3/4) are missing.\n");
             destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("launchFailed");
+            cleanupUserDataDirOnExit("pipeFdsMissing");
             return 1;
         }
-        writeDebug(`launchResult code=${launchResult.code} stdout=${launchResult.stdout.trim()} stderr=${launchResult.stderr.trim()}`);
-        const chromePid = Number.parseInt(launchResult.stdout.trim(), 10);
-        if (!Number.isFinite(chromePid)) {
-            writeDebug(`invalidChromePid output=${launchResult.stdout}`);
-            process.stderr.write(`[wsl-chrome-bridge] failed to parse Chrome PID from PowerShell output: ${launchResult.stdout}\n`);
+        if (!usePipeTransport && !useLocalProxyTransport) {
+            process.stderr.write("[wsl-chrome-bridge] missing transport channel. " +
+                "Provide --remote-debugging-port (Playwright mode) or launch with OS pipes fd3/fd4.\n");
             destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("invalidChromePid");
+            cleanupUserDataDirOnExit("missingTransportChannel");
             return 1;
         }
-        let remoteVersion = null;
-        const startAt = Date.now();
-        while (Date.now() - startAt < CHROME_READY_TIMEOUT_MS) {
-            const result = await runPowerShellFile(powerShell, getVersionScript.windowsPath, [String(planWithResolvedPort.windowsDebugPort)], { timeoutMs: 4_000 });
-            if (result.code === 0 && result.stdout.trim()) {
-                try {
-                    remoteVersion = JSON.parse(result.stdout.trim());
-                    writeDebug(`remoteVersion=${JSON.stringify(remoteVersion)}`);
-                    break;
+        const waitForRemoteVersion = async (windowsDebugPort, phase) => {
+            const startAt = Date.now();
+            while (Date.now() - startAt < CHROME_READY_TIMEOUT_MS) {
+                const result = await runPowerShellFile(powerShell, getVersionScript.windowsPath, [String(windowsDebugPort)], { timeoutMs: 4_000 });
+                if (result.code === 0 && result.stdout.trim()) {
+                    try {
+                        const version = JSON.parse(result.stdout.trim());
+                        if (typeof version.webSocketDebuggerUrl === "string") {
+                            writeDebug(`remoteVersion phase=${phase} port=${windowsDebugPort} payload=${JSON.stringify(version)}`);
+                            return version;
+                        }
+                        writeDebug(`remoteVersionMissingWs phase=${phase} port=${windowsDebugPort} payload=${result.stdout.trim()}`);
+                    }
+                    catch {
+                        writeDebug(`remoteVersionParseFailed phase=${phase} port=${windowsDebugPort} raw=${result.stdout.trim()}`);
+                    }
                 }
-                catch {
-                    writeDebug(`remoteVersionParseFailed raw=${result.stdout.trim()}`);
-                    // ignore malformed JSON and retry
+                else if (debug) {
+                    writeDebug(`waitVersion retry phase=${phase} port=${windowsDebugPort} code=${result.code} stdout=${result.stdout.trim()} stderr=${result.stderr.trim()}`);
                 }
+                await sleep(POLL_INTERVAL_MS);
             }
-            else if (debug) {
-                writeDebug(`waitVersion retry code=${result.code} stdout=${result.stdout.trim()} stderr=${result.stderr.trim()}`);
+            return null;
+        };
+        const tryReuseExistingChromeSession = async (phase) => {
+            if (!plan.windowsUserDataDir) {
+                writeDebug(`existingChrome skip phase=${phase} reason=no-windows-user-data-dir`);
+                return null;
             }
-            await sleep(POLL_INTERVAL_MS);
-        }
-        if (!remoteVersion || typeof remoteVersion.webSocketDebuggerUrl !== "string") {
-            writeDebug("chromeDebugWsNotReady");
-            process.stderr.write("[wsl-chrome-bridge] Chrome debug websocket was not ready in time.\n");
-            await runPowerShellFile(powerShell, stopProcessScript.windowsPath, [String(chromePid)], {
-                timeoutMs: 3_000
+            const existingResult = await runPowerShellFile(powerShell, findExistingChromeScript.windowsPath, [plan.windowsUserDataDir], { timeoutMs: 8_000 });
+            if (existingResult.code !== 0) {
+                writeDebug(`existingChrome query failed phase=${phase} code=${existingResult.code} stdout=${existingResult.stdout.trim()} stderr=${existingResult.stderr.trim()}`);
+                return null;
+            }
+            const existingMatch = parseExistingChromeMatch(existingResult.stdout);
+            if (!existingMatch) {
+                writeDebug(`existingChrome miss phase=${phase}`);
+                return null;
+            }
+            writeDebug(`existingChrome hit phase=${phase} port=${existingMatch.port} pid=${existingMatch.pid ?? "unknown"} headless=${existingMatch.headless}`);
+            const version = await waitForRemoteVersion(existingMatch.port, phase);
+            if (!version || typeof version.webSocketDebuggerUrl !== "string") {
+                writeDebug(`existingChrome stale phase=${phase} port=${existingMatch.port} pid=${existingMatch.pid ?? "unknown"}`);
+                return null;
+            }
+            if (existingMatch.headless !== requestedHeadlessMode) {
+                const existingMode = existingMatch.headless ? "headless" : "headed";
+                const requestedMode = requestedHeadlessMode ? "headless" : "headed";
+                throw new Error(`headless mode mismatch for shared --user-data-dir "${plan.windowsUserDataDir}". Existing Chrome mode is ${existingMode}, requested mode is ${requestedMode}. Use a different --user-data-dir per mode, or close the existing Chrome instance first.`);
+            }
+            return {
+                windowsDebugPort: existingMatch.port,
+                remoteVersion: version,
+                remoteBrowserWsUrl: version.webSocketDebuggerUrl,
+                ownership: "attached",
+                chromePid: null,
+                launchedExecutablePath: null
+            };
+        };
+        const launchChromeSession = async (phase) => {
+            const resolvePortMode = plan.windowsDebugPortSource === "auto-random" ? "random" : "fixed";
+            const resolvePortResult = await runPowerShellFile(powerShell, resolvePortScript.windowsPath, [String(plan.windowsDebugPort), resolvePortMode], { timeoutMs: 8_000 });
+            if (resolvePortResult.code !== 0) {
+                throw new Error(`failed to resolve an available Windows debug port: ${resolvePortResult.stderr || resolvePortResult.stdout}`);
+            }
+            const resolvedWindowsDebugPort = Number.parseInt(resolvePortResult.stdout.trim(), 10);
+            if (!Number.isFinite(resolvedWindowsDebugPort)) {
+                throw new Error("failed to parse resolved Windows debug port from PowerShell output.");
+            }
+            writeDebug(`resolvedWindowsDebugPort phase=${phase} port=${resolvedWindowsDebugPort} source=${plan.windowsDebugPortSource} mode=${resolvePortMode}`);
+            const planWithResolvedPort = {
+                ...plan,
+                windowsDebugPort: resolvedWindowsDebugPort
+            };
+            const chromePath = resolveChromeCommand({
+                env,
+                bridgeChromeExecutablePath: plan.bridgeChromeExecutablePath
             });
-            destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("chromeDebugWsNotReady");
-            return 1;
+            const windowsArgs = buildWindowsChromeArgs(planWithResolvedPort, env);
+            writeDebug(`chromePath phase=${phase} path=${chromePath}`);
+            writeDebug(`windowsArgs phase=${phase} args=${JSON.stringify(windowsArgs)}`);
+            const launchResult = await runPowerShellFile(powerShell, launchScript.windowsPath, [chromePath, ...windowsArgs], { timeoutMs: 15_000 });
+            if (launchResult.code !== 0) {
+                throw new Error(`failed to launch Windows Chrome: ${launchResult.stderr || launchResult.stdout}`);
+            }
+            writeDebug(`launchResult phase=${phase} code=${launchResult.code} stdout=${launchResult.stdout.trim()} stderr=${launchResult.stderr.trim()}`);
+            const launchedPid = Number.parseInt(launchResult.stdout.trim(), 10);
+            if (Number.isFinite(launchedPid)) {
+                writeDebug(`launchResult phase=${phase} pid=${launchedPid}`);
+            }
+            else {
+                writeDebug(`launchResult phase=${phase} pid=unknown raw=${launchResult.stdout.trim()}`);
+            }
+            const version = await waitForRemoteVersion(resolvedWindowsDebugPort, phase);
+            if (!version || typeof version.webSocketDebuggerUrl !== "string") {
+                throw new Error("Chrome debug websocket was not ready in time.");
+            }
+            return {
+                windowsDebugPort: resolvedWindowsDebugPort,
+                remoteVersion: version,
+                remoteBrowserWsUrl: version.webSocketDebuggerUrl,
+                ownership: "launched",
+                chromePid: Number.isFinite(launchedPid) ? launchedPid : null,
+                launchedExecutablePath: chromePath
+            };
+        };
+        const establishChromeSession = async (phase) => {
+            const existing = await tryReuseExistingChromeSession(phase);
+            if (existing) {
+                return existing;
+            }
+            return await launchChromeSession(phase);
+        };
+        let startupSession;
+        try {
+            startupSession = await establishChromeSession("startup");
         }
-        const remoteBrowserWsUrl = remoteVersion.webSocketDebuggerUrl;
-        writeDebug(`remoteBrowserWsUrl=${remoteBrowserWsUrl}`);
-        const relayChild = spawn(powerShell.powershellPath, [
-            "-NoLogo",
-            "-NoProfile",
-            "-NonInteractive",
-            "-ExecutionPolicy",
-            "Bypass",
-            "-File",
-            relayScript.windowsPath,
-            remoteBrowserWsUrl
-        ], {
-            env,
-            stdio: ["pipe", "pipe", "pipe"]
-        });
-        relayChild.stdout.setEncoding("utf8");
-        relayChild.stderr.setEncoding("utf8");
-        const usePipeTransport = plan.usePipeTransport && hasPipeFds();
-        const useLocalProxyTransport = plan.localProxyPort !== null;
-        writeDebug(`transportMode requestedPipe=${plan.usePipeTransport} pipe=${usePipeTransport} localProxy=${useLocalProxyTransport} localProxyPort=${plan.localProxyPort ?? "none"}`);
-        if (plan.usePipeTransport && !usePipeTransport) {
-            process.stderr.write("[wsl-chrome-bridge] --remote-debugging-pipe was requested but OS pipe fds (3/4) are missing.\n");
-            await runPowerShellFile(powerShell, stopProcessScript.windowsPath, [String(chromePid)], {
-                timeoutMs: 3_000
-            });
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeDebug(`startupSession failed message=${message}`);
+            process.stderr.write(`[wsl-chrome-bridge] ${message}\n`);
             destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("pipeFdsMissing");
+            cleanupUserDataDirOnExit("startupSessionFailed");
             return 1;
         }
-        if (!usePipeTransport && !useLocalProxyTransport) {
-            process.stderr.write("[wsl-chrome-bridge] missing transport channel. " +
-                "Provide --remote-debugging-port (Playwright mode) or launch with OS pipes fd3/fd4.\n");
-            await runPowerShellFile(powerShell, stopProcessScript.windowsPath, [String(chromePid)], {
-                timeoutMs: 3_000
+        let activeRemoteBrowserWsUrl = startupSession.remoteBrowserWsUrl;
+        let activeWindowsDebugPort = startupSession.windowsDebugPort;
+        let activeOwnership = startupSession.ownership;
+        let activeChromePid = startupSession.chromePid;
+        let activeLaunchedExecutablePath = startupSession.launchedExecutablePath;
+        const startupRemoteVersion = startupSession.remoteVersion;
+        writeDebug(`startupSession established ownership=${activeOwnership} port=${activeWindowsDebugPort} chromePid=${activeChromePid ?? "unknown"} ws=${activeRemoteBrowserWsUrl}`);
+        const startBridgeWatchdog = (chromePid) => {
+            const watchdogScriptPath = fileURLToPath(new URL("./bridge-watchdog.js", import.meta.url));
+            const watchdogArgs = [
+                watchdogScriptPath,
+                "--bridge-pid",
+                String(process.pid),
+                "--chrome-pid",
+                String(chromePid),
+                "--powershell-path",
+                powerShell.powershellPath
+            ];
+            if (activeLaunchedExecutablePath) {
+                watchdogArgs.push("--expected-executable-path", activeLaunchedExecutablePath);
+            }
+            if (activeDebugFile) {
+                watchdogArgs.push("--debug-file", activeDebugFile);
+            }
+            const watchdog = spawn(process.execPath, watchdogArgs, {
+                env,
+                detached: true,
+                stdio: "ignore"
             });
-            destroyPowerShellContext(powerShell);
-            cleanupUserDataDirOnExit("missingTransportChannel");
-            return 1;
+            watchdog.unref();
+            writeDebug(`watchdog started pid=${watchdog.pid ?? "unknown"} bridgePid=${process.pid} chromePid=${chromePid}`);
+        };
+        if (usePipeTransport && requestedHeadlessMode && activeOwnership === "launched" && activeChromePid) {
+            startBridgeWatchdog(activeChromePid);
         }
         let pipeIn = null;
         let pipeOut = null;
@@ -556,14 +836,18 @@ export function createBridgeRunner() {
             pipeIn = createReadStream("", { fd: 3, autoClose: false });
             pipeOut = createWriteStream("", { fd: 4, autoClose: false });
         }
-        const remoteBrowserPath = parseBrowserPathFromWsUrl(remoteBrowserWsUrl);
+        const remoteBrowserPath = parseBrowserPathFromWsUrl(activeRemoteBrowserWsUrl);
         const localBrowserWsUrl = plan.localProxyPort === null
             ? null
             : `ws://127.0.0.1:${plan.localProxyPort}${remoteBrowserPath}`;
         let localProxy = null;
+        const earlyWsMessages = [];
+        let handleLocalProxyMessage = (message) => {
+            earlyWsMessages.push(message);
+        };
         if (plan.localProxyPort !== null && localBrowserWsUrl) {
             const localVersionPayload = {
-                ...remoteVersion,
+                ...startupRemoteVersion,
                 webSocketDebuggerUrl: localBrowserWsUrl
             };
             try {
@@ -574,12 +858,7 @@ export function createBridgeRunner() {
                     localVersionPayload,
                     writeDebug,
                     onClientMessage: (message) => {
-                        if (relayConnected) {
-                            relayChild.stdin.write(`${message}\n`);
-                        }
-                        else {
-                            queuedForRelay.push(message);
-                        }
+                        handleLocalProxyMessage(message);
                     }
                 });
                 writeDebug(`localProxy listening ws=${localBrowserWsUrl}`);
@@ -592,25 +871,27 @@ export function createBridgeRunner() {
                 const message = error instanceof Error ? error.message : String(error);
                 writeDebug(`localProxy start failed: ${message}`);
                 process.stderr.write(`[wsl-chrome-bridge] failed to start local websocket proxy on 127.0.0.1:${plan.localProxyPort}: ${message}\n`);
-                try {
-                    relayChild.kill("SIGTERM");
-                }
-                catch {
-                    // ignore
-                }
-                await runPowerShellFile(powerShell, stopProcessScript.windowsPath, [String(chromePid)], {
-                    timeoutMs: 3_000
-                });
+                pipeIn?.destroy();
+                pipeOut?.destroy();
                 destroyPowerShellContext(powerShell);
                 cleanupUserDataDirOnExit("localProxyStartFailed");
                 return 1;
             }
         }
+        let relayState = "connecting";
         let relayConnected = false;
         let relayStdoutBuffer = "";
         let relayStderrBuffer = "";
+        let relayGeneration = 0;
+        let relayChild = null;
         let pendingFromPipe = Buffer.alloc(0);
         const queuedForRelay = [];
+        let relayBootstrapPending = false;
+        let recoveryPromise = null;
+        const disconnectSignals = new Set();
+        const recentWeakDisconnectEvents = [];
+        let strongDisconnectAtMs = null;
+        let latestDisconnectAssessment = null;
         let closed = false;
         const cleanup = async (code) => {
             if (closed) {
@@ -624,23 +905,27 @@ export function createBridgeRunner() {
                 await localProxy.close();
                 writeDebug("cleanup localProxy closed");
             }
-            try {
-                relayChild.stdin.end();
-            }
-            catch {
-                // ignore
-            }
-            try {
-                relayChild.kill("SIGTERM");
+            const child = relayChild;
+            relayChild = null;
+            if (child) {
+                try {
+                    child.stdin?.end();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch {
+                    // ignore
+                }
+                await Promise.race([once(child, "exit"), sleep(1_000)]);
             }
-            catch {
-                // ignore
+            if (usePipeTransport && requestedHeadlessMode && plan.windowsUserDataDir) {
+                const stopResult = await runPowerShellFile(powerShell, stopChromeScript.windowsPath, [plan.windowsUserDataDir, String(activeWindowsDebugPort)], { timeoutMs: 8_000 });
+                writeDebug(`cleanup stopHeadlessChrome code=${stopResult.code} port=${activeWindowsDebugPort} ownership=${activeOwnership} stdout=${stopResult.stdout.trim()} stderr=${stopResult.stderr.trim()}`);
             }
-            await Promise.race([once(relayChild, "exit"), sleep(1_000)]);
-            await runPowerShellFile(powerShell, stopProcessScript.windowsPath, [String(chromePid)], {
-                timeoutMs: 3_000
-            });
-            writeDebug("cleanup stopProcess done");
             destroyPowerShellContext(powerShell);
             writeDebug("cleanup powershell context destroyed");
             cleanupUserDataDirOnExit("cleanup");
@@ -651,6 +936,7 @@ export function createBridgeRunner() {
         const signalHandlers = new Map();
         return await new Promise((resolvePromise) => {
             let resolving = false;
+            let shuttingDown = false;
             const clear = () => {
                 for (const [signal, handler] of signalHandlers) {
                     process.off(signal, handler);
@@ -661,66 +947,422 @@ export function createBridgeRunner() {
                     return;
                 }
                 resolving = true;
+                shuttingDown = true;
                 clear();
                 void cleanup(code).then(resolvePromise);
             };
-            for (const signal of signals) {
-                const handler = () => finalize(0);
-                signalHandlers.set(signal, handler);
-                process.on(signal, handler);
-            }
-            relayChild.stderr.on("data", (chunk) => {
-                relayStderrBuffer += chunk;
-                while (true) {
-                    const newlineIndex = relayStderrBuffer.indexOf("\n");
-                    if (newlineIndex === -1) {
+            const noteDisconnectSignal = (signal, source) => {
+                if (disconnectSignals.has(signal)) {
+                    return;
+                }
+                disconnectSignals.add(signal);
+                writeDebug(`disconnectSignal observed signal=${signal} source=${source}`);
+            };
+            const rememberWeakDisconnectEvent = (signal, rawJson, observedAtMs) => {
+                recentWeakDisconnectEvents.push({ signal, rawJson, observedAtMs });
+                if (recentWeakDisconnectEvents.length > DISCONNECT_EVENT_BUFFER_LIMIT) {
+                    recentWeakDisconnectEvents.splice(0, recentWeakDisconnectEvents.length - DISCONNECT_EVENT_BUFFER_LIMIT);
+                }
+                writeDebug(`disconnectEvent cached signal=${signal} cacheSize=${recentWeakDisconnectEvents.length}`);
+            };
+            const writeDisconnectAssessment = (trigger, disconnectAtMs) => {
+                const effectiveDisconnectAtMs = strongDisconnectAtMs ?? disconnectAtMs ?? Date.now();
+                const assessment = assessDisconnectSignals(disconnectSignals, recentWeakDisconnectEvents, effectiveDisconnectAtMs, DISCONNECT_EVENT_TIME_WINDOW_MS);
+                writeDebug(`disconnectAssessment trigger=${trigger} weakSignalSeen=${assessment.weakSignalSeen} strongSignalSeen=${assessment.strongSignalSeen} weakSignalWithinWindow=${assessment.weakSignalWithinWindow} windowMs=${DISCONNECT_EVENT_TIME_WINDOW_MS} disconnectAtMs=${effectiveDisconnectAtMs} chromeDisconnectedLikely=${assessment.chromeDisconnectedLikely} nearbyWeakEventCount=${assessment.nearbyWeakEventCount} disconnectSignals=${assessment.summary}`);
+                if (assessment.nearbyWeakEvents.length > 0) {
+                    writeDebugBlock(`disconnectAssessment nearbyWeakEvents trigger=${trigger}`, assessment.nearbyWeakEvents);
+                }
+                return assessment;
+            };
+            const markRelayState = (nextState, reason, disconnectAssessment = null) => {
+                if (nextState !== "degraded") {
+                    latestDisconnectAssessment = null;
+                }
+                else if (disconnectAssessment) {
+                    latestDisconnectAssessment = disconnectAssessment;
+                }
+                if (relayState === nextState) {
+                    writeDebug(`relayState unchanged state=${nextState} reason=${reason}`);
+                    return;
+                }
+                relayState = nextState;
+                const assessmentSuffix = disconnectAssessment
+                    ? ` disconnectSignals=${disconnectAssessment.summary} weakSignalWithinWindow=${disconnectAssessment.weakSignalWithinWindow} nearbyWeakEventCount=${disconnectAssessment.nearbyWeakEventCount} chromeDisconnectedLikely=${disconnectAssessment.chromeDisconnectedLikely}`
+                    : "";
+                writeDebug(`relayState changed state=${relayState} reason=${reason} port=${activeWindowsDebugPort} ownership=${activeOwnership}${assessmentSuffix}`);
+            };
+            const nextInternalCdpRequestId = () => {
+                internalCdpRequestId += 1;
+                return internalCdpRequestId;
+            };
+            const sendRecoveryAutoAttachBootstrap = (child, generation) => {
+                if (!child.stdin) {
+                    return false;
+                }
+                const payload = {
+                    id: nextInternalCdpRequestId(),
+                    method: "Target.setAutoAttach",
+                    params: {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: true,
+                        flatten: true
+                    }
+                };
+                const message = JSON.stringify(payload);
+                const rendered = renderCdpMessage(message);
+                pendingInternalCdpRequests.set(requestKey(payload.id, null), {
+                    generation,
+                    method: payload.method,
+                    purpose: "recovery-auto-attach"
+                });
+                writeDebugBlock("CDP(bridge-internal -> chrome) Request Target.setAutoAttach", rendered.payload);
+                child.stdin.write(`${message}\n`);
+                return true;
+            };
+            const tryHandleInternalCdpResponse = (generation, rendered, child) => {
+                if (rendered.parsed.kind !== "response" || rendered.parsed.id === null) {
+                    return false;
+                }
+                const key = requestKey(rendered.parsed.id, rendered.parsed.sessionId);
+                const pending = pendingInternalCdpRequests.get(key);
+                if (!pending) {
+                    return false;
+                }
+                pendingInternalCdpRequests.delete(key);
+                writeDebugBlock(`CDP(chrome -> bridge-internal) Response ${pending.method}`, rendered.payload);
+                if (pending.generation !== generation) {
+                    return true;
+                }
+                if (pending.purpose === "recovery-auto-attach") {
+                    relayBootstrapPending = false;
+                    if (rendered.parsed.hasError) {
+                        relayConnected = false;
+                        const assessment = writeDisconnectAssessment("recoveryBootstrapAutoAttachError");
+                        markRelayState("degraded", "recoveryBootstrapAutoAttachError", assessment);
+                        try {
+                            child.kill("SIGTERM");
+                        }
+                        catch {
+                            // ignore
+                        }
+                        maybeRecoverRelayForWs();
+                        return true;
+                    }
+                    writeDebug("recoveryBootstrap autoAttach acknowledged");
+                    flushQueuedForRelay();
+                }
+                return true;
+            };
+            const flushQueuedForRelay = () => {
+                if (!relayChild || !relayConnected || !relayChild.stdin || relayBootstrapPending) {
+                    return;
+                }
+                const relayStdin = relayChild.stdin;
+                while (queuedForRelay.length > 0) {
+                    const queued = queuedForRelay.shift();
+                    if (!queued) {
                         break;
                     }
-                    const rawLine = relayStderrBuffer.slice(0, newlineIndex);
-                    relayStderrBuffer = relayStderrBuffer.slice(newlineIndex + 1);
-                    const line = rawLine.replace(/\r$/, "");
-                    if (!line) {
-                        continue;
+                    relayStdin.write(`${queued.message}\n`);
+                    writeCdpHopLog("relay=>chrome", queued.rendered);
+                }
+            };
+            const forwardToUpstream = (message, rendered) => {
+                if (pipeOut) {
+                    pipeOut.write(message);
+                    pipeOut.write("\0");
+                    writeCdpHopLog("relay=>upstream", rendered);
+                }
+                if (localProxy) {
+                    localProxy.broadcast(message);
+                    writeCdpHopLog("relay=>upstream", rendered);
+                }
+            };
+            const sendToRelayOrQueue = (message, rendered) => {
+                if (relayState === "connected" &&
+                    relayChild &&
+                    relayConnected &&
+                    relayChild.stdin &&
+                    !relayBootstrapPending) {
+                    relayChild.stdin.write(`${message}\n`);
+                    writeCdpHopLog("relay=>chrome", rendered);
+                    return;
+                }
+                queuedForRelay.push({ message, rendered });
+            };
+            const startRelay = (remoteBrowserWsUrl, reason) => {
+                if (shuttingDown) {
+                    writeDebug(`startRelay skipped reason=shuttingDown trigger=${reason}`);
+                    return;
+                }
+                disconnectSignals.clear();
+                recentWeakDisconnectEvents.length = 0;
+                strongDisconnectAtMs = null;
+                relayBootstrapPending = false;
+                pendingInternalCdpRequests.clear();
+                relayGeneration += 1;
+                const generation = relayGeneration;
+                markRelayState("connecting", reason);
+                relayConnected = false;
+                relayStdoutBuffer = "";
+                relayStderrBuffer = "";
+                const previousRelayChild = relayChild;
+                const child = spawn(powerShell.powershellPath, [
+                    "-NoLogo",
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-File",
+                    relayScript.windowsPath,
+                    remoteBrowserWsUrl
+                ], {
+                    env,
+                    stdio: ["pipe", "pipe", "pipe"]
+                });
+                child.stdout.setEncoding("utf8");
+                child.stderr.setEncoding("utf8");
+                relayChild = child;
+                if (previousRelayChild) {
+                    try {
+                        previousRelayChild.stdin?.end();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    try {
+                        previousRelayChild.kill("SIGTERM");
+                    }
+                    catch {
+                        // ignore
                     }
-                    writeDebug(`relayStderr ${line}`);
-                    if (line.includes("CONNECTED")) {
-                        relayConnected = true;
-                        for (const queued of queuedForRelay) {
-                            relayChild.stdin.write(`${queued}\n`);
+                }
+                child.stderr.on("data", (chunk) => {
+                    if (generation !== relayGeneration) {
+                        return;
+                    }
+                    relayStderrBuffer += chunk;
+                    while (true) {
+                        const newlineIndex = relayStderrBuffer.indexOf("\n");
+                        if (newlineIndex === -1) {
+                            break;
+                        }
+                        const rawLine = relayStderrBuffer.slice(0, newlineIndex);
+                        relayStderrBuffer = relayStderrBuffer.slice(newlineIndex + 1);
+                        const line = rawLine.replace(/\r$/, "");
+                        if (!line) {
+                            continue;
+                        }
+                        writeDebug(`relayStderr ${line}`);
+                        const strongDisconnectSignal = detectStrongDisconnectSignalFromRelayLog(line);
+                        if (strongDisconnectSignal) {
+                            noteDisconnectSignal(strongDisconnectSignal, "relayStderr");
+                            const observedAtMs = Date.now();
+                            strongDisconnectAtMs = observedAtMs;
+                            relayConnected = false;
+                            const assessment = writeDisconnectAssessment(`relayStrongDisconnect:${strongDisconnectSignal}`, observedAtMs);
+                            if (usePipeTransport) {
+                                finalize(1);
+                            }
+                            else {
+                                relayBootstrapPending = false;
+                                markRelayState("degraded", `relayStrongDisconnect:${strongDisconnectSignal}`, assessment);
+                                try {
+                                    child.kill("SIGTERM");
+                                }
+                                catch {
+                                    // ignore
+                                }
+                            }
+                            return;
+                        }
+                        if (line.includes("CONNECTED")) {
+                            relayConnected = true;
+                            markRelayState("connected", "relayConnected");
+                            if (!usePipeTransport && reason === "recovery") {
+                                relayBootstrapPending = true;
+                                const sent = sendRecoveryAutoAttachBootstrap(child, generation);
+                                if (!sent) {
+                                    relayBootstrapPending = false;
+                                    relayConnected = false;
+                                    const assessment = writeDisconnectAssessment("recoveryBootstrapSendFailed");
+                                    markRelayState("degraded", "recoveryBootstrapSendFailed", assessment);
+                                    try {
+                                        child.kill("SIGTERM");
+                                    }
+                                    catch {
+                                        // ignore
+                                    }
+                                    maybeRecoverRelayForWs();
+                                    return;
+                                }
+                                continue;
+                            }
+                            flushQueuedForRelay();
+                            continue;
+                        }
+                        if (line.startsWith("FATAL:")) {
+                            const assessment = writeDisconnectAssessment(`relayFatal:${line}`);
+                            if (usePipeTransport) {
+                                finalize(1);
+                            }
+                            else {
+                                relayConnected = false;
+                                relayBootstrapPending = false;
+                                markRelayState("degraded", `relayFatal:${line}`, assessment);
+                            }
+                            return;
                         }
-                        queuedForRelay.length = 0;
-                        continue;
                     }
-                    if (line.startsWith("FATAL:")) {
-                        finalize(1);
+                });
+                child.stdout.on("data", (chunk) => {
+                    if (generation !== relayGeneration) {
                         return;
                     }
-                }
-            });
-            relayChild.stdout.on("data", (chunk) => {
-                relayStdoutBuffer += chunk;
-                while (true) {
-                    const newlineIndex = relayStdoutBuffer.indexOf("\n");
-                    if (newlineIndex === -1) {
-                        break;
+                    relayStdoutBuffer += chunk;
+                    while (true) {
+                        const newlineIndex = relayStdoutBuffer.indexOf("\n");
+                        if (newlineIndex === -1) {
+                            break;
+                        }
+                        const rawLine = relayStdoutBuffer.slice(0, newlineIndex);
+                        relayStdoutBuffer = relayStdoutBuffer.slice(newlineIndex + 1);
+                        const line = rawLine.replace(/\r$/, "");
+                        if (!line) {
+                            continue;
+                        }
+                        const rendered = renderCdpMessage(line);
+                        if (tryHandleInternalCdpResponse(generation, rendered, child)) {
+                            continue;
+                        }
+                        const weakDisconnectSignal = detectWeakDisconnectSignalFromCdp(rendered);
+                        if (weakDisconnectSignal) {
+                            noteDisconnectSignal(weakDisconnectSignal, "chromeEvent");
+                            rememberWeakDisconnectEvent(weakDisconnectSignal, line, Date.now());
+                        }
+                        writeCdpHopLog("chrome=>relay", rendered);
+                        forwardToUpstream(line, rendered);
+                    }
+                });
+                child.once("error", () => {
+                    if (generation !== relayGeneration) {
+                        return;
                     }
-                    const rawLine = relayStdoutBuffer.slice(0, newlineIndex);
-                    relayStdoutBuffer = relayStdoutBuffer.slice(newlineIndex + 1);
-                    const line = rawLine.replace(/\r$/, "");
-                    if (!line) {
-                        continue;
+                    relayConnected = false;
+                    relayBootstrapPending = false;
+                    const assessment = writeDisconnectAssessment("relayError");
+                    if (usePipeTransport) {
+                        finalize(1);
                     }
-                    if (pipeOut) {
-                        pipeOut.write(line);
-                        pipeOut.write("\0");
+                    else {
+                        markRelayState("degraded", "relayError", assessment);
+                    }
+                });
+                child.once("exit", (code) => {
+                    if (generation !== relayGeneration) {
+                        return;
                     }
-                    if (localProxy) {
-                        localProxy.broadcast(line);
+                    relayConnected = false;
+                    relayBootstrapPending = false;
+                    relayChild = null;
+                    const assessment = writeDisconnectAssessment(`relayExit:${code ?? "null"}`);
+                    if (usePipeTransport) {
+                        finalize(code === 0 ? 0 : 1);
+                        return;
                     }
+                    markRelayState("degraded", `relayExit:${code ?? "null"}`, assessment);
+                });
+            };
+            const maybeRecoverRelayForWs = () => {
+                if (usePipeTransport || relayState !== "degraded") {
+                    return;
                 }
-            });
-            relayChild.once("error", () => finalize(1));
-            relayChild.once("exit", (code) => finalize(code === 0 ? 0 : 1));
+                if (shuttingDown || closed || resolving) {
+                    writeDebug("recovery skipped reason=shuttingDown");
+                    return;
+                }
+                if (recoveryPromise) {
+                    return;
+                }
+                recoveryPromise = (async () => {
+                    writeDebug("recovery start trigger=upstreamRequest");
+                    const recoverySession = await establishChromeSession("recovery");
+                    activeRemoteBrowserWsUrl = recoverySession.remoteBrowserWsUrl;
+                    activeWindowsDebugPort = recoverySession.windowsDebugPort;
+                    activeOwnership = recoverySession.ownership;
+                    activeChromePid = recoverySession.chromePid;
+                    activeLaunchedExecutablePath = recoverySession.launchedExecutablePath;
+                    writeDebug(`recovery success ownership=${activeOwnership} port=${activeWindowsDebugPort} chromePid=${activeChromePid ?? "unknown"} ws=${activeRemoteBrowserWsUrl}`);
+                    startRelay(activeRemoteBrowserWsUrl, "recovery");
+                })()
+                    .catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    writeDebug(`recovery failed message=${message}`);
+                    process.stderr.write(`[wsl-chrome-bridge] recovery failed: ${message}\n`);
+                    finalize(1);
+                })
+                    .finally(() => {
+                    recoveryPromise = null;
+                });
+            };
+            const processUpstreamMessage = (message) => {
+                if (shuttingDown || closed || resolving) {
+                    writeDebug("upstream message ignored reason=shuttingDown");
+                    return;
+                }
+                const rendered = renderCdpMessage(message);
+                writeCdpHopLog("upstream=>relay", rendered);
+                const shouldShortCircuitKnownClosedBrowserClose = !usePipeTransport &&
+                    relayState !== "connected" &&
+                    rendered.parsed.kind === "request" &&
+                    rendered.canonicalMethod === "Browser.close" &&
+                    rendered.parsed.id !== null &&
+                    Boolean(latestDisconnectAssessment?.chromeDisconnectedLikely);
+                if (shouldShortCircuitKnownClosedBrowserClose) {
+                    const syntheticResponse = {
+                        id: rendered.parsed.id,
+                        result: {}
+                    };
+                    if (rendered.parsed.sessionId) {
+                        syntheticResponse.sessionId = rendered.parsed.sessionId;
+                    }
+                    const syntheticMessage = JSON.stringify(syntheticResponse);
+                    const syntheticRendered = renderCdpMessage(syntheticMessage);
+                    writeDebug(`shortCircuit Browser.close reason=chromeAlreadyClosed relayState=${relayState} id=${String(rendered.parsed.id)} session=${rendered.parsed.sessionId ?? "root"}`);
+                    forwardToUpstream(syntheticMessage, syntheticRendered);
+                    return;
+                }
+                if (!usePipeTransport && relayState === "degraded") {
+                    maybeRecoverRelayForWs();
+                    sendToRelayOrQueue(message, rendered);
+                    return;
+                }
+                if (!usePipeTransport && relayState === "connecting") {
+                    sendToRelayOrQueue(message, rendered);
+                    return;
+                }
+                if (!usePipeTransport && (!relayConnected || relayState !== "connected")) {
+                    const assessment = writeDisconnectAssessment("upstreamWhileRelayUnavailable");
+                    markRelayState("degraded", "upstreamWhileRelayUnavailable", assessment);
+                    maybeRecoverRelayForWs();
+                    sendToRelayOrQueue(message, rendered);
+                    return;
+                }
+                sendToRelayOrQueue(message, rendered);
+            };
+            handleLocalProxyMessage = (message) => {
+                processUpstreamMessage(message);
+            };
+            for (const earlyMessage of earlyWsMessages) {
+                processUpstreamMessage(earlyMessage);
+            }
+            earlyWsMessages.length = 0;
+            for (const signal of signals) {
+                const handler = () => finalize(0);
+                signalHandlers.set(signal, handler);
+                process.on(signal, handler);
+            }
+            startRelay(activeRemoteBrowserWsUrl, "initial");
             if (pipeIn) {
                 pipeIn.on("data", (chunk) => {
                     const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
@@ -735,12 +1377,7 @@ export function createBridgeRunner() {
                         if (!message) {
                             continue;
                         }
-                        if (relayConnected) {
-                            relayChild.stdin.write(`${message}\n`);
-                        }
-                        else {
-                            queuedForRelay.push(message);
-                        }
+                        processUpstreamMessage(message);
                     }
                 });
                 pipeIn.once("end", () => finalize(0));