execbro 0.0.1-reserve → 1.10.13

package/build/core/connection.js

@@ -0,0 +1,1710 @@
+import WebSocket from "ws";
+import { connectedApps, pendingExecutions, getNextMessageId, getLogBuffer, getNetworkBuffer, setActiveSimulatorUdid, clearActiveSimulatorIfSource, updateLastCDPMessageTime, getLastCDPMessageTime, clearLastCDPMessageTime } from "./state.js";
+import { mapConsoleType } from "./logs.js";
+import { injectNetworkInterceptor, sendNetworkEnable, isInterceptorEvent, applyInterceptedEvent } from "./networkInterceptor.js";
+import { findSimulatorByName } from "./ios.js";
+import { getAdbIdForAvd } from "./android.js";
+import { fetchDevices, selectMainDevice, scanMetroPorts } from "./metro.js";
+import { probeCdpAlive } from "./probe.js";
+import { UserInputError } from "./errors.js";
+import { scheduleAppDetection } from "./appDetection.js";
+import { markConnectionEstablished } from "./jsExecute.js";
+import { DEFAULT_RECONNECTION_CONFIG, MIN_STABLE_CONNECTION_MS, initConnectionState, updateConnectionState, getConnectionState, recordConnectionGap, closeConnectionGap, saveConnectionMetadata, clearConnectionMetadata, getConnectionMetadata, saveReconnectionTimer, cancelReconnectionTimer, calculateBackoffDelay, initContextHealth, markContextHealthy, markContextStale, getContextHealth, updateContextHealth, formatDuration, recordConnectionEvent, } from "./connectionState.js";
+// Connection locks to prevent concurrent connection attempts to the same device
+const connectionLocks = new Set();
+// Track Network.enable message IDs to detect CDP network support
+const pendingNetworkEnableIds = new Set();
+// Track SDK-probe message IDs so we can decode their responses and set
+// app.sdkPresent. The probe runs on connect and then periodically because
+// the SDK's init() may execute after we attach.
+const pendingSdkProbeIds = new Map(); // msgId -> appKey
+const SDK_PROBE_INITIAL_DELAY_MS = 200;
+const SDK_PROBE_INTERVAL_MS = 3000;
+// Consecutive SDK-absent probes required to flip sdkPresent true→false.
+// Hysteresis against the post-reload window where the JS context exists but
+// the SDK's init() hasn't re-run yet (see ConnectedApp.sdkMissCount).
+const SDK_ABSENCE_CONFIRM_COUNT = 2;
+// Fast re-probe schedule after a context is (re)created, so the SDK is
+// re-detected within a few hundred ms instead of waiting up to a full
+// SDK_PROBE_INTERVAL_MS tick. Covers reloads not driven by reload_app
+// (shake-to-reload, Metro "r").
+const SDK_REPROBE_DELAYS_MS = [200, 500, 1000, 2000];
+function sendSdkProbe(ws, appKey) {
+    if (ws.readyState !== WebSocket.OPEN)
+        return;
+    const id = getNextMessageId();
+    pendingSdkProbeIds.set(id, appKey);
+    try {
+        ws.send(JSON.stringify({
+            id,
+            method: "Runtime.evaluate",
+            params: {
+                expression: 'typeof (globalThis.__EXECBRO__ ?? globalThis.__RN_AI_DEVTOOLS__)?.getNetworkEntries === "function"',
+                returnByValue: true
+            }
+        }));
+    }
+    catch {
+        pendingSdkProbeIds.delete(id);
+    }
+}
+function startSdkProbeLoop(ws, appKey) {
+    const initial = setTimeout(() => sendSdkProbe(ws, appKey), SDK_PROBE_INITIAL_DELAY_MS);
+    const interval = setInterval(() => {
+        const app = connectedApps.get(appKey);
+        if (!app || ws.readyState !== WebSocket.OPEN) {
+            clearInterval(interval);
+            return;
+        }
+        sendSdkProbe(ws, appKey);
+    }, SDK_PROBE_INTERVAL_MS);
+    const app = connectedApps.get(appKey);
+    if (app) {
+        app.sdkProbeTimer = interval;
+    }
+    // Best-effort cleanup if the socket closes before the initial probe fires
+    ws.once("close", () => {
+        clearTimeout(initial);
+        clearInterval(interval);
+    });
+}
+// Fire a burst of SDK probes on the heels of a (re)created execution context.
+// After a reload the context is recreated but the SDK's init() re-runs slightly
+// later; without this, sdkPresent only recovers on the next 3s interval tick,
+// widening the window where get_network_requests falls off the SDK buffer.
+function scheduleFastSdkReprobe(ws, appKey) {
+    for (const delay of SDK_REPROBE_DELAYS_MS) {
+        const t = setTimeout(() => {
+            if (!connectedApps.has(appKey) || ws.readyState !== WebSocket.OPEN)
+                return;
+            sendSdkProbe(ws, appKey);
+        }, delay);
+        ws.once("close", () => clearTimeout(t));
+    }
+}
+// Suppress auto-reconnection for intentionally disconnected devices
+const reconnectionSuppressed = new Set();
+/**
+ * Suppress auto-reconnection for all current connections.
+ * Used by disconnect_metro to prevent close handlers from re-connecting.
+ */
+export function suppressReconnection() {
+    for (const key of connectedApps.keys()) {
+        reconnectionSuppressed.add(key);
+    }
+}
+/**
+ * Suppress auto-reconnection for a specific connection key.
+ * Used by disconnect_metro with device targeting.
+ */
+export function suppressReconnectionForKey(appKey) {
+    reconnectionSuppressed.add(appKey);
+}
+/**
+ * Clear reconnection suppression (called when user explicitly reconnects via scan_metro).
+ */
+export function clearReconnectionSuppression() {
+    reconnectionSuppressed.clear();
+}
+const STALE_ACTIVITY_THRESHOLD_MS = 30_000;
+const PING_INTERVAL_MS = 1_000; // WebSocket ping/pong keepalive interval
+/**
+ * Max time (ms) to wait for a Runtime.evaluate("1+1") reply during liveness probing.
+ * Tight budget: live targets respond in under 50ms; zombie CDP targets never respond.
+ */
+const PROBE_TIMEOUT_MS = 1500;
+const RECONNECT_SETTLE_MS = 500;
+/**
+ * Creates a WebSocket connection with Origin header fallback.
+ * RN 0.85+ Metro requires the Origin header, but Expo SDK 55 Bridgeless
+ * rejects connections that include one. The rejection can manifest as:
+ *   - Connection refused before open (error/close before open event)
+ *   - Immediate close after open (open fires, then close with code 1006)
+ * Tries with Origin first, falls back to without on quick failure.
+ */
+export function createWebSocketWithOriginFallback(url, timeoutMs = 5000) {
+    const STABILIZE_MS = 500; // Wait after open to detect immediate close
+    return new Promise((resolve, reject) => {
+        const wsUrl = new URL(url);
+        const origin = `http://${wsUrl.hostname}:${wsUrl.port}`;
+        let settled = false;
+        const tryConnect = (withOrigin) => {
+            const options = withOrigin ? { headers: { Origin: origin } } : undefined;
+            const ws = new WebSocket(url, options);
+            let opened = false;
+            ws.on("open", () => {
+                opened = true;
+                if (withOrigin) {
+                    // Wait briefly to detect immediate close (Expo SDK 55 pattern)
+                    setTimeout(() => {
+                        if (settled)
+                            return;
+                        if (ws.readyState === WebSocket.OPEN) {
+                            settled = true;
+                            console.error("[execbro] WebSocket connected with Origin header");
+                            resolve(ws);
+                        }
+                        // If not OPEN, the close handler will trigger fallback
+                    }, STABILIZE_MS);
+                }
+                else {
+                    if (settled)
+                        return;
+                    settled = true;
+                    console.error("[execbro] WebSocket connected without Origin header");
+                    resolve(ws);
+                }
+            });
+            const handleFailure = (error) => {
+                if (settled)
+                    return;
+                ws.removeAllListeners();
+                ws.terminate();
+                if (withOrigin) {
+                    const reason = opened ? "immediately closed after open" : "rejected before open";
+                    console.error(`[execbro] Origin header connection ${reason}, retrying without...`);
+                    tryConnect(false);
+                }
+                else {
+                    settled = true;
+                    reject(error || new Error("WebSocket connection failed"));
+                }
+            };
+            ws.on("error", (err) => handleFailure(err));
+            ws.on("close", () => handleFailure());
+        };
+        tryConnect(true);
+        setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                reject(new Error("WebSocket connection timed out"));
+            }
+        }, timeoutMs);
+    });
+}
+// Helper to find appKey from device info by searching connectedApps
+function findAppKeyForDevice(device) {
+    for (const [key, app] of connectedApps.entries()) {
+        if (app.deviceInfo.id === device.id) {
+            return key;
+        }
+    }
+    return null;
+}
+// Helper to convert WebSocket readyState to readable name
+export function getWebSocketStateName(state) {
+    switch (state) {
+        case WebSocket.CONNECTING: return "CONNECTING";
+        case WebSocket.OPEN: return "OPEN";
+        case WebSocket.CLOSING: return "CLOSING";
+        case WebSocket.CLOSED: return "CLOSED";
+        default: return `UNKNOWN(${state})`;
+    }
+}
+/**
+ * Purge stale connections for scanned ports.
+ * When Metro restarts with a different app, /json returns new device IDs.
+ * Old connections keyed by the previous device IDs remain in connectedApps.
+ * This function removes connections on scanned ports whose device IDs
+ * are no longer present in the fresh device list from Metro.
+ */
+export function purgeStaleConnectionsForPorts(freshDevicesByPort) {
+    const purged = [];
+    const scannedPorts = new Set(freshDevicesByPort.keys());
+    for (const [appKey, app] of connectedApps.entries()) {
+        // Only check connections on ports we just scanned
+        if (!scannedPorts.has(app.port))
+            continue;
+        const freshDevices = freshDevicesByPort.get(app.port) || [];
+        // Check both device ID and appId — device IDs are per-physical-device
+        // (stable across Metro restarts), so a different app on the same device
+        // would have the same ID but a different appId
+        const matchingDevice = freshDevices.find(d => d.id === app.deviceInfo.id);
+        const stillValid = matchingDevice && matchingDevice.appId === app.deviceInfo.appId;
+        if (!stillValid) {
+            const name = app.deviceInfo.deviceName || app.deviceInfo.title;
+            const reason = !matchingDevice
+                ? "device no longer in Metro /json"
+                : `appId changed: ${app.deviceInfo.appId} → ${matchingDevice.appId}`;
+            console.error(`[execbro] Purging stale connection: ${name} (port ${app.port}, id ${app.deviceInfo.id}) — ${reason}`);
+            // Suppress reconnection so close handler doesn't try to reconnect
+            reconnectionSuppressed.add(appKey);
+            cancelReconnectionTimer(appKey);
+            clearLastCDPMessageTime(appKey);
+            clearActiveSimulatorIfSource(appKey);
+            try {
+                app.ws.close();
+            }
+            catch { /* ignore */ }
+            connectedApps.delete(appKey);
+            purged.push(name);
+        }
+    }
+    return purged;
+}
+// Format CDP RemoteObject to readable string
+export function formatRemoteObject(result) {
+    if (result.type === "undefined") {
+        return "undefined";
+    }
+    if (result.subtype === "null") {
+        return "null";
+    }
+    // For objects/arrays with a value, stringify it
+    if (result.value !== undefined) {
+        if (typeof result.value === "object") {
+            return JSON.stringify(result.value, null, 2);
+        }
+        return String(result.value);
+    }
+    // Use description for complex objects
+    if (result.description) {
+        return result.description;
+    }
+    // Handle unserializable values (NaN, Infinity, etc.)
+    if (result.unserializableValue) {
+        return result.unserializableValue;
+    }
+    return `[${result.type}${result.subtype ? ` ${result.subtype}` : ""}]`;
+}
+/**
+ * Extract a clean, informative error message from CDP exception details
+ * Handles various error formats from Hermes and other JS engines
+ */
+function extractExceptionMessage(exceptionDetails) {
+    const parts = [];
+    // Get the exception object if available
+    const exc = exceptionDetails.exception;
+    if (exc) {
+        // For error objects, className tells us the error type (ReferenceError, TypeError, etc.)
+        const errorType = exc.className || (exc.subtype === 'error' ? 'Error' : '');
+        // The description usually contains "ErrorType: message" or full stack trace
+        // We want to extract just the first line (the actual error message)
+        if (exc.description) {
+            const firstLine = exc.description.split('\n')[0].trim();
+            // If description already includes the error type, use it directly
+            if (firstLine.includes(':')) {
+                parts.push(firstLine);
+            }
+            else if (errorType) {
+                // Combine error type with description
+                parts.push(`${errorType}: ${firstLine}`);
+            }
+            else {
+                parts.push(firstLine);
+            }
+        }
+        else if (exc.value !== undefined) {
+            // For primitive exceptions (throw "string" or throw 123)
+            const valueStr = typeof exc.value === 'string' ? exc.value : JSON.stringify(exc.value);
+            if (errorType) {
+                parts.push(`${errorType}: ${valueStr}`);
+            }
+            else {
+                parts.push(valueStr);
+            }
+        }
+        else if (errorType) {
+            // Just the error type, no message
+            parts.push(errorType);
+        }
+    }
+    // Fall back to exceptionDetails.text if we couldn't extract from exception object
+    // But avoid just "Uncaught" which is not helpful
+    if (parts.length === 0) {
+        const text = exceptionDetails.text;
+        if (text && text.toLowerCase() !== 'uncaught') {
+            parts.push(text);
+        }
+    }
+    // Add location info for syntax/compilation errors (helps identify the problem)
+    if (exceptionDetails.lineNumber !== undefined && exceptionDetails.columnNumber !== undefined) {
+        // Only add location if it's meaningful (not 0:0 which is often just wrapper)
+        if (exceptionDetails.lineNumber > 0 || exceptionDetails.columnNumber > 0) {
+            parts.push(`at line ${exceptionDetails.lineNumber}:${exceptionDetails.columnNumber}`);
+        }
+    }
+    // If we still have nothing, provide a generic message
+    if (parts.length === 0) {
+        return 'JavaScript execution failed (no error details available)';
+    }
+    return parts.join(' ');
+}
+// Format a CDP object preview recursively
+function formatPreview(preview) {
+    const isArray = preview.subtype === "array";
+    const props = preview.properties || [];
+    const formatted = props.map((p) => {
+        let value;
+        if (p.valuePreview) {
+            value = formatPreview(p.valuePreview);
+        }
+        else if (p.subtype === "null") {
+            value = "null";
+        }
+        else if (p.type === "string") {
+            value = `"${p.value}"`;
+        }
+        else {
+            value = p.value ?? "undefined";
+        }
+        return isArray ? value : `${p.name}: ${value}`;
+    });
+    const overflow = preview.overflow ? ", ..." : "";
+    return isArray
+        ? `[${formatted.join(", ")}${overflow}]`
+        : `{${formatted.join(", ")}${overflow}}`;
+}
+// Format a single CDP console argument (sync — without object resolution)
+function formatConsoleArg(arg) {
+    // Explicit undefined (matches browser: console.log(undefined) → "undefined")
+    if (arg.type === "undefined") {
+        return "undefined";
+    }
+    // Primitives
+    if (arg.type === "string" || arg.type === "number" || arg.type === "boolean") {
+        return String(arg.value);
+    }
+    // Objects/arrays with preview — expand inline
+    if (arg.preview?.properties) {
+        return formatPreview(arg.preview);
+    }
+    // Raw value (e.g. null sent as value)
+    if (arg.value !== undefined) {
+        return JSON.stringify(arg.value);
+    }
+    // Description fallback (functions, symbols, errors without preview)
+    if (arg.description) {
+        return arg.description;
+    }
+    // Object without any resolved data
+    if (arg.type === "object") {
+        return "[Object]";
+    }
+    return `[${arg.type || "unknown"}]`;
+}
+// Fetch object properties via CDP Runtime.getProperties
+function fetchObjectProperties(ws, objectId, depth = 2) {
+    return new Promise((resolve) => {
+        const msgId = getNextMessageId();
+        const timeout = setTimeout(() => {
+            resolve("Object"); // Fallback on timeout
+        }, 3000);
+        const handler = (data) => {
+            try {
+                const response = JSON.parse(data.toString());
+                if (response.id === msgId) {
+                    clearTimeout(timeout);
+                    ws.removeListener("message", handler);
+                    if (response.result?.result) {
+                        resolve(formatCDPProperties(ws, response.result.result, depth));
+                    }
+                    else {
+                        resolve("Object");
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        };
+        ws.on("message", handler);
+        ws.send(JSON.stringify({
+            id: msgId,
+            method: "Runtime.getProperties",
+            params: { objectId, ownProperties: true, generatePreview: true }
+        }));
+    });
+}
+// Format CDP property descriptors into a readable string
+async function formatCDPProperties(ws, properties, depth) {
+    const parts = [];
+    let isArrayLike = false;
+    // Detect arrays by checking for numeric keys and "length" property
+    const propNames = properties.filter((p) => !p.isAccessor && p.name !== "__proto__").map((p) => p.name);
+    const hasLength = propNames.includes("length");
+    const numericKeys = propNames.filter((n) => /^\d+$/.test(n));
+    if (hasLength && numericKeys.length > 0 && numericKeys.length >= propNames.length - 1) {
+        isArrayLike = true;
+    }
+    const filteredProps = properties.filter((p) => !p.isAccessor && p.name !== "__proto__" && (!isArrayLike || p.name !== "length"));
+    for (const prop of filteredProps) {
+        const val = prop.value;
+        if (!val)
+            continue;
+        const formatted = await formatPropertyValue(ws, val, depth - 1);
+        if (isArrayLike) {
+            parts.push(formatted);
+        }
+        else {
+            parts.push(`${prop.name}: ${formatted}`);
+        }
+    }
+    return isArrayLike
+        ? `[${parts.join(", ")}]`
+        : `{${parts.join(", ")}}`;
+}
+// Format a single property value
+async function formatPropertyValue(ws, val, remainingDepth) {
+    const type = val.type;
+    const subtype = val.subtype;
+    if (subtype === "null")
+        return "null";
+    if (type === "undefined")
+        return "undefined";
+    if (type === "string")
+        return `"${val.value}"`;
+    if (type === "number" || type === "boolean")
+        return String(val.value);
+    if (type === "function")
+        return "[Function]";
+    // Nested object — recurse if depth allows
+    if (type === "object" && val.objectId && remainingDepth > 0) {
+        return fetchObjectProperties(ws, val.objectId, remainingDepth);
+    }
+    // Object but no depth left — use description
+    if (type === "object") {
+        return val.description || "[Object]";
+    }
+    if (val.value !== undefined)
+        return JSON.stringify(val.value);
+    if (val.description)
+        return val.description;
+    return `[${type}]`;
+}
+// Resolve all object args in a console message, returning formatted text
+async function resolveConsoleArgs(ws, args) {
+    const parts = await Promise.all(args.map(async (arg) => {
+        // Primitives — format synchronously
+        if (arg.type === "string" || arg.type === "number" || arg.type === "boolean") {
+            return String(arg.value);
+        }
+        // Objects/arrays with preview — expand inline
+        if (arg.preview?.properties) {
+            return formatPreview(arg.preview);
+        }
+        // Object with objectId — fetch properties via CDP
+        if (arg.type === "object" && arg.objectId) {
+            return fetchObjectProperties(ws, arg.objectId);
+        }
+        // Raw value
+        if (arg.value !== undefined) {
+            return JSON.stringify(arg.value);
+        }
+        // Description fallback
+        if (arg.description) {
+            return arg.description;
+        }
+        return "[object]";
+    }));
+    return parts.join(" ");
+}
+// Handle CDP messages
+export function handleCDPMessage(message, device, ws) {
+    // Track last CDP activity for connection liveness detection (per-device)
+    const cdpAppKey = findAppKeyForDevice(device);
+    if (cdpAppKey) {
+        updateLastCDPMessageTime(cdpAppKey, new Date());
+    }
+    const deviceName = device.deviceName || device.title || "unknown";
+    // Handle responses to our requests (e.g., Runtime.evaluate)
+    if (typeof message.id === "number") {
+        const pending = pendingExecutions.get(message.id);
+        if (pending) {
+            clearTimeout(pending.timeoutId);
+            pendingExecutions.delete(message.id);
+            // Check for CDP-level error (protocol error, not JS exception)
+            if (message.error) {
+                const error = message.error;
+                // Build comprehensive error message including code and data if available
+                const parts = [];
+                if (error.message)
+                    parts.push(error.message);
+                if (error.code !== undefined)
+                    parts.push(`(code: ${error.code})`);
+                if (error.data)
+                    parts.push(`- ${error.data}`);
+                const errorMessage = parts.length > 0 ? parts.join(' ') : 'Unknown CDP protocol error';
+                pending.resolve({ success: false, error: errorMessage });
+                return;
+            }
+            // Check for JavaScript exception in result
+            const result = message.result;
+            if (result?.exceptionDetails) {
+                const errorMessage = extractExceptionMessage(result.exceptionDetails);
+                pending.resolve({ success: false, error: errorMessage });
+                return;
+            }
+            // Success - format the result
+            if (result?.result) {
+                pending.resolve({ success: true, result: formatRemoteObject(result.result) });
+                return;
+            }
+            pending.resolve({ success: true, result: "undefined" });
+        }
+        // Track SDK-probe responses
+        if (pendingSdkProbeIds.has(message.id)) {
+            const appKey = pendingSdkProbeIds.get(message.id);
+            pendingSdkProbeIds.delete(message.id);
+            const app = connectedApps.get(appKey);
+            if (app) {
+                const result = message.result?.result;
+                const present = result?.value === true;
+                const wasPresent = app.sdkPresent === true;
+                // Hysteresis on the true→false edge: tolerate transient SDK
+                // absence right after a reload (context recreated, init() not
+                // re-run yet) so we don't restore duplicate-prone CDP/interceptor
+                // writes and bounce get_network_requests off the SDK buffer.
+                let nextPresent = present;
+                if (!present && wasPresent) {
+                    app.sdkMissCount = (app.sdkMissCount ?? 0) + 1;
+                    if (app.sdkMissCount < SDK_ABSENCE_CONFIRM_COUNT) {
+                        nextPresent = true; // hold "present" until absence is confirmed
+                    }
+                    else {
+                        app.sdkMissCount = 0;
+                    }
+                }
+                else {
+                    app.sdkMissCount = 0;
+                }
+                app.sdkPresent = nextPresent;
+                if (nextPresent !== wasPresent) {
+                    console.error(`[execbro] SDK ${present ? "detected" : "no longer detected"} on ${app.deviceInfo.title}; CDP/JS-interceptor buffer writes ${present ? "suppressed" : "restored"}`);
+                    // Toggle the in-app interceptor's emit flag so it stops
+                    // (or resumes) producing console.debug lines and CDP
+                    // traffic. Fire-and-forget — the flag is idempotent.
+                    if (app.ws.readyState === WebSocket.OPEN) {
+                        try {
+                            app.ws.send(JSON.stringify({
+                                id: getNextMessageId(),
+                                method: "Runtime.evaluate",
+                                params: {
+                                    expression: `globalThis.__RN_NET_DISABLED__ = ${present ? "true" : "false"}`,
+                                    returnByValue: true
+                                }
+                            }));
+                        }
+                        catch {
+                            // ignore — next probe will retry
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        // Track Network.enable responses to detect CDP network support
+        if (pendingNetworkEnableIds.has(message.id)) {
+            pendingNetworkEnableIds.delete(message.id);
+            const nAppKey = findAppKeyForDevice(device);
+            if (nAppKey) {
+                const app = connectedApps.get(nAppKey);
+                if (app) {
+                    if (message.error) {
+                        app.cdpNetworkSupported = false;
+                        console.error(`[execbro] CDP Network domain not supported, using JS interceptor`);
+                    }
+                    else {
+                        app.cdpNetworkSupported = true;
+                        console.error(`[execbro] CDP Network domain supported`);
+                    }
+                }
+            }
+        }
+        return;
+    }
+    const method = message.method;
+    // Handle Runtime.consoleAPICalled
+    if (method === "Runtime.consoleAPICalled") {
+        const params = message.params;
+        const type = params.type || "log";
+        const level = mapConsoleType(type);
+        const args = params.args || [];
+        // Check for network interceptor events before processing as logs
+        const interceptorJson = isInterceptorEvent(args);
+        if (interceptorJson !== null) {
+            const iAppKey = findAppKeyForDevice(device);
+            const iApp = iAppKey ? connectedApps.get(iAppKey) : null;
+            // Skip when CDP Network domain is the source, OR when the in-app
+            // SDK is the source — both would otherwise produce duplicate
+            // entries for every request.
+            if (!iApp?.cdpNetworkSupported && !iApp?.sdkPresent) {
+                applyInterceptedEvent(interceptorJson, getNetworkBuffer(deviceName));
+            }
+            return;
+        }
+        // Check if any args need async object resolution
+        const hasObjectArgs = ws && args.some((a) => a.type === "object" && a.objectId && !a.preview?.properties);
+        if (hasObjectArgs) {
+            // Resolve object args asynchronously via CDP
+            resolveConsoleArgs(ws, args).then((messageText) => {
+                getLogBuffer(deviceName).add({
+                    timestamp: new Date(),
+                    level,
+                    message: messageText || "[console call with empty resolution]",
+                    args: args.map((a) => a.value)
+                });
+            }).catch(() => {
+                // Fallback to sync formatting on error
+                const messageText = args.map(formatConsoleArg).join(" ");
+                getLogBuffer(deviceName).add({
+                    timestamp: new Date(),
+                    level,
+                    message: messageText || "[console call with unresolvable args]",
+                    args: args.map((a) => a.value)
+                });
+            });
+        }
+        else {
+            const messageText = args.map(formatConsoleArg).join(" ");
+            if (messageText.trim()) {
+                getLogBuffer(deviceName).add({
+                    timestamp: new Date(),
+                    level,
+                    message: messageText,
+                    args: args.map((a) => a.value)
+                });
+            }
+        }
+    }
+    // Handle Log.entryAdded
+    if (method === "Log.entryAdded") {
+        const params = message.params;
+        if (params.entry) {
+            const level = mapConsoleType(params.entry.level || "log");
+            getLogBuffer(deviceName).add({
+                timestamp: new Date(),
+                level,
+                message: params.entry.text || ""
+            });
+        }
+    }
+    // Handle Network.requestWillBeSent
+    if (method === "Network.requestWillBeSent") {
+        // Skip CDP capture when the in-app SDK is the source of truth —
+        // otherwise every request lands in both buffers under different ids.
+        // The follow-up Network.responseReceived/loadingFinished/loadingFailed
+        // handlers below only mutate existing entries, so they self-skip.
+        const nAppKey = findAppKeyForDevice(device);
+        const nApp = nAppKey ? connectedApps.get(nAppKey) : null;
+        if (nApp?.sdkPresent) {
+            return;
+        }
+        // An arriving Network.requestWillBeSent is proof the CDP Network domain
+        // is active. Some backends (e.g. RN 0.85 Bridgeless/Hermes) enable the
+        // domain but never send a response to Network.enable, so the
+        // response-based detection above never fires and cdpNetworkSupported
+        // stays undefined — leaving the JS interceptor un-suppressed and every
+        // request double-captured (CDP + interceptor). Mark support here so the
+        // interceptor dedup guard (see Runtime.consoleAPICalled handler) trips.
+        if (nApp && !nApp.cdpNetworkSupported) {
+            nApp.cdpNetworkSupported = true;
+            console.error(`[execbro] CDP Network domain active (detected via requestWillBeSent on ${nApp.deviceInfo.title})`);
+        }
+        const params = message.params;
+        const request = {
+            requestId: params.requestId,
+            timestamp: new Date(),
+            method: params.request.method,
+            url: params.request.url,
+            headers: params.request.headers || {},
+            postData: params.request.postData,
+            timing: {
+                requestTime: params.timestamp
+            },
+            completed: false
+        };
+        getNetworkBuffer(deviceName).set(params.requestId, request);
+    }
+    // Handle Network.responseReceived
+    if (method === "Network.responseReceived") {
+        const params = message.params;
+        const existing = getNetworkBuffer(deviceName).get(params.requestId);
+        if (existing) {
+            existing.status = params.response.status;
+            existing.statusText = params.response.statusText;
+            existing.responseHeaders = params.response.headers || {};
+            existing.mimeType = params.response.mimeType;
+            if (params.timestamp && existing.timing?.requestTime) {
+                existing.timing.responseTime = params.timestamp;
+            }
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
+        }
+    }
+    // Handle Network.loadingFinished
+    if (method === "Network.loadingFinished") {
+        const params = message.params;
+        const existing = getNetworkBuffer(deviceName).get(params.requestId);
+        if (existing) {
+            existing.completed = true;
+            existing.contentLength = params.encodedDataLength;
+            if (params.timestamp && existing.timing?.requestTime) {
+                existing.timing.duration = Math.round((params.timestamp - existing.timing.requestTime) * 1000);
+            }
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
+        }
+    }
+    // Handle Network.loadingFailed
+    if (method === "Network.loadingFailed") {
+        const params = message.params;
+        const existing = getNetworkBuffer(deviceName).get(params.requestId);
+        if (existing) {
+            existing.completed = true;
+            existing.error = params.canceled ? "Canceled" : (params.errorText || "Request failed");
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
+        }
+    }
+    // Handle Runtime context lifecycle events for health tracking
+    const appKey = findAppKeyForDevice(device);
+    if (appKey) {
+        // Handle Runtime.executionContextCreated
+        if (method === "Runtime.executionContextCreated") {
+            const params = message.params;
+            markContextHealthy(appKey, params.context.id);
+            console.error(`[execbro] Context created: ${params.context.id}`);
+            // Re-inject network interceptor and re-check CDP Network support
+            const ctxApp = connectedApps.get(appKey);
+            if (ctxApp?.ws?.readyState === WebSocket.OPEN) {
+                injectNetworkInterceptor(ctxApp.ws);
+                const nEnableId = sendNetworkEnable(ctxApp.ws);
+                pendingNetworkEnableIds.add(nEnableId);
+                // The context was just recreated (e.g. reload). Re-probe the SDK
+                // quickly so sdkPresent re-establishes within a few hundred ms
+                // instead of on the next 3s interval tick.
+                scheduleFastSdkReprobe(ctxApp.ws, appKey);
+            }
+        }
+        // Handle Runtime.executionContextDestroyed
+        if (method === "Runtime.executionContextDestroyed") {
+            markContextStale(appKey);
+            console.error(`[execbro] Context destroyed`);
+        }
+        // Handle Runtime.executionContextsCleared
+        if (method === "Runtime.executionContextsCleared") {
+            markContextStale(appKey);
+            console.error(`[execbro] All contexts cleared`);
+        }
+    }
+}
+// Connect to a device via CDP WebSocket
+export async function connectToDevice(device, port, options = {}) {
+    const { isReconnection = false, reconnectionConfig = DEFAULT_RECONNECTION_CONFIG } = options;
+    return new Promise(async (resolve, reject) => {
+        const appKey = `${port}-${device.id}`;
+        // Check if already connected with a valid WebSocket
+        const existingApp = connectedApps.get(appKey);
+        if (existingApp) {
+            if (existingApp.ws.readyState === WebSocket.OPEN) {
+                // Verify WebSocket is actually alive with a ping/pong check.
+                // readyState can show OPEN even when the remote end is gone
+                // (TCP hasn't timed out yet, especially after Metro restart).
+                const isAlive = await new Promise((pongResolve) => {
+                    const timeout = setTimeout(() => pongResolve(false), 2000);
+                    existingApp.ws.once("pong", () => {
+                        clearTimeout(timeout);
+                        pongResolve(true);
+                    });
+                    try {
+                        existingApp.ws.ping();
+                    }
+                    catch {
+                        clearTimeout(timeout);
+                        pongResolve(false);
+                    }
+                });
+                if (isAlive) {
+                    resolve(`Already connected to ${device.title}`);
+                    return;
+                }
+                // Ping failed — connection is dead, clean up
+                console.error(`[execbro] Existing connection to ${device.title} failed liveness check (no pong), reconnecting`);
+                recordConnectionEvent("liveness-failed", appKey, device.title, "no pong within 2000ms");
+                reconnectionSuppressed.add(appKey);
+                try {
+                    existingApp.ws.terminate();
+                }
+                catch { /* ignore */ }
+                connectedApps.delete(appKey);
+                clearLastCDPMessageTime(appKey);
+                clearActiveSimulatorIfSource(appKey);
+            }
+            else {
+                // WebSocket exists but not OPEN - clean up stale entry
+                console.error(`[execbro] Cleaning up stale connection for ${device.title} (state: ${getWebSocketStateName(existingApp.ws.readyState)})`);
+                connectedApps.delete(appKey);
+            }
+        }
+        // Skip if this device is already connected on a different port
+        // (Metro's /json advertises all devices it can see, even ones built by other Metro servers)
+        const deviceName = device.deviceName || device.title;
+        for (const [existingKey, existingApp] of connectedApps.entries()) {
+            if (existingKey !== appKey && existingApp.ws.readyState === WebSocket.OPEN) {
+                const existingName = existingApp.deviceInfo.deviceName || existingApp.deviceInfo.title;
+                if (existingName === deviceName) {
+                    resolve(`Skipped ${deviceName} (already connected on port ${existingApp.port})`);
+                    return;
+                }
+            }
+        }
+        // Prevent concurrent connection attempts to the same device
+        if (connectionLocks.has(appKey)) {
+            resolve(`Connection already in progress for ${device.title}`);
+            return;
+        }
+        connectionLocks.add(appKey);
+        // Cancel any pending reconnection timer for this appKey
+        cancelReconnectionTimer(appKey);
+        // Save connection metadata for potential reconnection
+        saveConnectionMetadata(appKey, {
+            port,
+            deviceInfo: device,
+            webSocketUrl: device.webSocketDebuggerUrl
+        });
+        try {
+            const ws = await createWebSocketWithOriginFallback(device.webSocketDebuggerUrl);
+            // Register close/error handlers IMMEDIATELY — before any async work
+            // below (probeCdpAlive, Runtime.enable, simctl/adb lookups). Previously
+            // they were attached only at the end of the setup block, so any close
+            // event during that window was silently swallowed: the entry stayed
+            // in connectedApps, readyState flipped to CLOSED, but no reconnect
+            // was scheduled and no `closed` event was recorded.
+            let pingInterval = null;
+            let staleRejected = false;
+            const handleClose = () => {
+                if (staleRejected)
+                    return; // probe-fail path handles its own cleanup
+                if (pingInterval) {
+                    clearInterval(pingInterval);
+                    pingInterval = null;
+                }
+                // Release connection lock if still held
+                connectionLocks.delete(appKey);
+                connectedApps.delete(appKey);
+                clearLastCDPMessageTime(appKey);
+                // Clear active simulator UDID if this connection set it
+                clearActiveSimulatorIfSource(appKey);
+                // Keep log and network buffers across reconnections
+                // They are only cleared on demand via clear_logs / clear_network tools
+                // Check if connection was stable before resetting attempts
+                const state = getConnectionState(appKey);
+                let wasStable = false;
+                if (state?.lastConnectedTime) {
+                    const connectionDuration = Date.now() - state.lastConnectedTime.getTime();
+                    wasStable = connectionDuration >= MIN_STABLE_CONNECTION_MS;
+                    if (wasStable) {
+                        // Connection was stable - reset attempts for fresh start
+                        updateConnectionState(appKey, { reconnectionAttempts: 0 });
+                        console.error(`[execbro] Connection was stable for ${Math.round(connectionDuration / 1000)}s, resetting reconnection attempts`);
+                    }
+                }
+                // Record the gap and trigger reconnection
+                recordConnectionGap(appKey, "Connection closed");
+                if (state) {
+                    updateConnectionState(appKey, {
+                        status: "disconnected",
+                        lastDisconnectTime: new Date()
+                    });
+                }
+                const uptimeMs = state?.lastConnectedTime ? Date.now() - state.lastConnectedTime.getTime() : 0;
+                const earlyPhase = state ? "" : " (before state init)";
+                console.error(`[execbro] Disconnected from ${device.title}${earlyPhase}`);
+                recordConnectionEvent("closed", appKey, device.title, `uptime ${formatDuration(uptimeMs)}${wasStable ? " (stable)" : " (unstable)"}${earlyPhase}`);
+                // Schedule auto-reconnection if enabled (skip if intentionally disconnected)
+                if (reconnectionConfig.enabled && !reconnectionSuppressed.has(appKey)) {
+                    // If close fired before initConnectionState, scheduleReconnection
+                    // would early-return (it requires existing state). Init it now
+                    // so the reconnect loop can still run.
+                    if (!state)
+                        initConnectionState(appKey);
+                    scheduleReconnection(appKey, reconnectionConfig);
+                }
+                else if (reconnectionSuppressed.has(appKey)) {
+                    reconnectionSuppressed.delete(appKey);
+                    console.error(`[execbro] Reconnection suppressed for ${device.title} (intentional disconnect)`);
+                    recordConnectionEvent("reconnect-suppressed", appKey, device.title, "intentional disconnect");
+                }
+                else if (!reconnectionConfig.enabled) {
+                    recordConnectionEvent("reconnect-suppressed", appKey, device.title, "reconnect disabled by caller");
+                }
+            };
+            ws.on("close", handleClose);
+            ws.on("error", (error) => {
+                console.error(`[execbro] WebSocket error for ${device.title}: ${error?.message || error}`);
+            });
+            // Verify the JS context is actually alive. Metro's /json can advertise
+            // zombie CDP pages that complete the WS handshake but no longer execute.
+            // A stale target here causes every downstream tool to time out or return
+            // degenerate state (e.g. __DEV__ === false on a debug bundle).
+            const alive = await probeCdpAlive(ws, PROBE_TIMEOUT_MS);
+            if (!alive) {
+                staleRejected = true;
+                ws.off("close", handleClose);
+                connectionLocks.delete(appKey);
+                try {
+                    ws.terminate();
+                }
+                catch { /* ignore */ }
+                clearConnectionMetadata(appKey);
+                console.error(`[execbro] Rejecting stale CDP target for ${device.title} (no probe response)`);
+                recordConnectionEvent("stale-target", appKey, device.title, `no probe response within ${PROBE_TIMEOUT_MS}ms${isReconnection ? " (during reconnect)" : ""}`);
+                resolve(`Skipped ${device.deviceName || device.title} (stale CDP target — no response from JS context)`);
+                return;
+            }
+            // Connection established — run setup
+            connectionLocks.delete(appKey);
+            connectedApps.set(appKey, { ws, deviceInfo: device, port, platform: "android" });
+            markConnectionEstablished();
+            // Initialize or update connection state
+            // Note: We do NOT reset reconnectionAttempts here - that happens
+            // only when connection has been stable for MIN_STABLE_CONNECTION_MS
+            if (isReconnection) {
+                closeConnectionGap(appKey);
+                updateConnectionState(appKey, {
+                    status: "connected",
+                    lastConnectedTime: new Date()
+                    // reconnectionAttempts NOT reset here - see ws.on("close") for stable connection check
+                });
+                // Reset context health for reconnection
+                initContextHealth(appKey);
+                console.error(`[execbro] Reconnected to ${device.title}`);
+                recordConnectionEvent("reconnect-success", appKey, device.title);
+            }
+            else {
+                initConnectionState(appKey);
+                initContextHealth(appKey);
+                console.error(`[execbro] Connected to ${device.title}`);
+                recordConnectionEvent("connect-success", appKey, device.title);
+            }
+            // Enable Runtime domain to receive console messages
+            ws.send(JSON.stringify({
+                id: getNextMessageId(),
+                method: "Runtime.enable"
+            }));
+            // Also enable Log domain
+            ws.send(JSON.stringify({
+                id: getNextMessageId(),
+                method: "Log.enable"
+            }));
+            // Inject JS network interceptor (immediate capture, may fail if context not ready)
+            injectNetworkInterceptor(ws);
+            // Also try CDP Network.enable (takes priority if supported)
+            const networkEnableId = sendNetworkEnable(ws);
+            pendingNetworkEnableIds.add(networkEnableId);
+            // Resolve native identifiers from the device name in parallel:
+            //   - iOS: simulator UDID via findSimulatorByName
+            //   - Android: adb serial via getAdbIdForAvd (maps AVD name → emulator-NNNN)
+            // Both are best-effort; failures are swallowed. Identifiers enable
+            // automatic device scoping and power the registry-first resolver fast path.
+            if (device.deviceName) {
+                const [simulatorUdid, adbSerial] = await Promise.all([
+                    findSimulatorByName(device.deviceName).catch(() => null),
+                    getAdbIdForAvd(device.deviceName).catch(() => null)
+                ]);
+                const connectedApp = connectedApps.get(appKey);
+                if (connectedApp) {
+                    if (simulatorUdid) {
+                        setActiveSimulatorUdid(simulatorUdid, appKey);
+                        connectedApp.platform = "ios";
+                        connectedApp.simulatorUdid = simulatorUdid;
+                        console.error(`[execbro] Linked to iOS simulator: ${simulatorUdid}`);
+                    }
+                    if (adbSerial) {
+                        connectedApp.platform = "android";
+                        connectedApp.adbSerial = adbSerial;
+                        console.error(`[execbro] Linked to Android emulator: ${adbSerial}`);
+                    }
+                }
+            }
+            // Fire-and-forget app detection (500ms delayed, non-blocking)
+            const appForDetection = connectedApps.get(appKey);
+            if (appForDetection) {
+                scheduleAppDetection(appForDetection);
+            }
+            // Start periodic SDK probe. When __RN_AI_DEVTOOLS__ is detected,
+            // app.sdkPresent flips to true and CDP/JS-interceptor buffer
+            // writes are suppressed (SDK becomes the single source).
+            startSdkProbeLoop(ws, appKey);
+            // Start WebSocket ping/pong keepalive to detect dead connections
+            // (especially important for physical devices over Wi-Fi).
+            // pingInterval was declared up-top so the early-registered close
+            // handler can clear it; close/error handlers are already attached.
+            let pongReceived = true;
+            pingInterval = setInterval(() => {
+                if (!pongReceived) {
+                    console.error(`[execbro] No pong from ${device.title}, terminating connection`);
+                    if (pingInterval) {
+                        clearInterval(pingInterval);
+                        pingInterval = null;
+                    }
+                    ws.terminate();
+                    return;
+                }
+                pongReceived = false;
+                ws.ping();
+            }, PING_INTERVAL_MS);
+            ws.on("pong", () => {
+                pongReceived = true;
+            });
+            ws.on("message", (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    handleCDPMessage(message, device, ws);
+                }
+                catch {
+                    // Ignore non-JSON messages
+                }
+            });
+            resolve(`Connected to ${device.title} (${device.deviceName})`);
+        }
+        catch (error) {
+            // Connection failed (both with and without Origin header)
+            connectionLocks.delete(appKey);
+            cancelReconnectionTimer(appKey);
+            connectedApps.delete(appKey);
+            clearLastCDPMessageTime(appKey);
+            clearActiveSimulatorIfSource(appKey);
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (!isReconnection) {
+                reject(`Failed to connect to ${device.title}: ${errorMsg}`);
+            }
+            else {
+                console.error(`[execbro] Reconnection error: ${errorMsg}`);
+            }
+        }
+    });
+}
+/**
+ * Schedule a reconnection attempt with exponential backoff
+ */
+function scheduleReconnection(appKey, config = DEFAULT_RECONNECTION_CONFIG) {
+    const state = getConnectionState(appKey);
+    if (!state)
+        return;
+    const meta = getConnectionMetadata(appKey);
+    const deviceTitle = meta?.deviceInfo.title;
+    const attempts = state.reconnectionAttempts;
+    if (attempts >= config.maxAttempts) {
+        console.error(`[execbro] Max reconnection attempts (${config.maxAttempts}) reached for ${appKey}`);
+        updateConnectionState(appKey, { status: "disconnected" });
+        recordConnectionEvent("max-attempts-reached", appKey, deviceTitle, `${config.maxAttempts} attempts exhausted`);
+        return;
+    }
+    const delay = calculateBackoffDelay(attempts, config);
+    console.error(`[execbro] Scheduling reconnection attempt ${attempts + 1}/${config.maxAttempts} in ${delay}ms`);
+    recordConnectionEvent("reconnect-scheduled", appKey, deviceTitle, `attempt ${attempts + 1}/${config.maxAttempts} in ${delay}ms`);
+    updateConnectionState(appKey, {
+        status: "reconnecting",
+        reconnectionAttempts: attempts + 1
+    });
+    const timer = setTimeout(() => {
+        attemptReconnection(appKey, config);
+    }, delay);
+    saveReconnectionTimer(appKey, timer);
+}
+/**
+ * Attempt to reconnect to a previously connected device
+ */
+async function attemptReconnection(appKey, config = DEFAULT_RECONNECTION_CONFIG) {
+    const metadata = getConnectionMetadata(appKey);
+    if (!metadata) {
+        console.error(`[execbro] No metadata for reconnection: ${appKey}`);
+        recordConnectionEvent("reconnect-failed", appKey, undefined, "no metadata");
+        return false;
+    }
+    const deviceTitle = metadata.deviceInfo.title;
+    recordConnectionEvent("reconnect-attempt", appKey, deviceTitle);
+    // Quick check: is Metro even running on this port?
+    const { scanMetroPorts } = await import("./metro.js");
+    const openPorts = await scanMetroPorts(metadata.port, metadata.port);
+    if (openPorts.length === 0) {
+        console.error(`[execbro] Metro not running on port ${metadata.port}, stopping reconnection for ${appKey}`);
+        updateConnectionState(appKey, { status: "disconnected" });
+        recordConnectionEvent("metro-down", appKey, deviceTitle, `port ${metadata.port} not open`);
+        return false;
+    }
+    try {
+        // Re-fetch devices to get fresh WebSocket URL (may have changed)
+        const devices = await fetchDevices(metadata.port);
+        // Try to find the same device first, otherwise select main device
+        const device = devices.find(d => d.id === metadata.deviceInfo.id)
+            || selectMainDevice(devices);
+        if (!device) {
+            console.error(`[execbro] Device no longer available for ${appKey}`);
+            recordConnectionEvent("reconnect-failed", appKey, deviceTitle, "device no longer advertised by Metro");
+            // Schedule next attempt
+            scheduleReconnection(appKey, config);
+            return false;
+        }
+        await connectToDevice(device, metadata.port, { isReconnection: true, reconnectionConfig: config });
+        return true;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[execbro] Reconnection failed: ${msg}`);
+        recordConnectionEvent("reconnect-failed", appKey, deviceTitle, msg);
+        // Schedule next attempt
+        scheduleReconnection(appKey, config);
+        return false;
+    }
+}
+// Get list of connected apps
+export function getConnectedApps() {
+    return Array.from(connectedApps.entries()).map(([key, app]) => ({
+        key,
+        app,
+        isConnected: app.ws.readyState === WebSocket.OPEN
+    }));
+}
+// Get first connected app with an OPEN WebSocket (or null if none)
+export function getFirstConnectedApp() {
+    // Find first app with OPEN WebSocket, cleaning up stale entries
+    for (const [key, app] of connectedApps.entries()) {
+        if (app.ws.readyState === WebSocket.OPEN) {
+            return app;
+        }
+        // Clean up stale entry
+        console.error(`[execbro] Cleaning up stale connection in getFirstConnectedApp: ${key} (state: ${getWebSocketStateName(app.ws.readyState)})`);
+        connectedApps.delete(key);
+    }
+    return null;
+}
+/**
+ * Find the connected RN app running on a specific iOS simulator (by UDID).
+ * Returns null if no connected app matches — caller should skip any CDP-based
+ * enrichment to avoid pulling data from a different simulator's app.
+ */
+export function getConnectedAppBySimulatorUdid(udid) {
+    for (const [key, app] of connectedApps.entries()) {
+        if (app.ws.readyState !== WebSocket.OPEN) {
+            connectedApps.delete(key);
+            continue;
+        }
+        if (app.platform === "ios" && app.simulatorUdid === udid) {
+            return app;
+        }
+    }
+    return null;
+}
+/**
+ * Find the connected RN app running on a specific Android device.
+ * Falls back to the sole connected Android app when `deviceId` is not provided
+ * or cannot be resolved via deviceName substring match — this keeps the common
+ * single-device case working while preventing cross-device data leakage when
+ * multiple Android apps are connected.
+ */
+export function getConnectedAppByAndroidDeviceId(deviceId) {
+    const androidApps = [];
+    for (const [key, app] of connectedApps.entries()) {
+        if (app.ws.readyState !== WebSocket.OPEN) {
+            connectedApps.delete(key);
+            continue;
+        }
+        if (app.platform === "android")
+            androidApps.push(app);
+    }
+    if (androidApps.length === 0)
+        return null;
+    if (androidApps.length === 1)
+        return androidApps[0];
+    if (deviceId) {
+        const lower = deviceId.toLowerCase();
+        const match = androidApps.find(a => {
+            const name = (a.deviceInfo.deviceName || a.deviceInfo.title || "").toLowerCase();
+            return name.includes(lower) || lower.includes(name);
+        });
+        if (match)
+            return match;
+    }
+    return null;
+}
+/**
+ * Lowercase and strip separators (whitespace, `_`, `-`) so substring matches
+ * survive punctuation drift between caller input and the device's reported
+ * identifier (e.g. "SM_A356N" vs "SM-A356N - 15 - API 35").
+ */
+function normalizeDeviceId(value) {
+    if (!value)
+        return "";
+    return value.toLowerCase().replace(/[\s_\-]+/g, "");
+}
+export function getConnectedAppByDevice(device) {
+    if (!device) {
+        return getFirstConnectedApp();
+    }
+    const lowerDevice = device.toLowerCase();
+    const normDevice = normalizeDeviceId(device);
+    const matches = [];
+    const allOpenNames = [];
+    for (const [key, app] of connectedApps.entries()) {
+        if (app.ws.readyState !== WebSocket.OPEN) {
+            connectedApps.delete(key);
+            continue;
+        }
+        const deviceName = app.deviceInfo.deviceName || app.deviceInfo.title || "";
+        allOpenNames.push(deviceName);
+        // Match against deviceName + the underlying hardware identifiers, with
+        // separator-insensitive normalization so "SM_A356N" finds
+        // "SM-A356N - 15 - API 35" and "emulator-5554" finds the Android app
+        // attached to that serial.
+        const haystacks = [
+            normalizeDeviceId(deviceName),
+            normalizeDeviceId(app.simulatorUdid),
+            normalizeDeviceId(app.adbSerial)
+        ].filter((s) => s.length > 0);
+        if (haystacks.some((h) => h.includes(normDevice))) {
+            matches.push(app);
+        }
+    }
+    // Prefer exact (case-insensitive) match when present — disambiguates
+    // "iPhone 17 Pro" from "iPhone 17 Pro Max" when both are connected.
+    const exact = matches.find(a => {
+        const name = a.deviceInfo.deviceName || a.deviceInfo.title || "";
+        return name.toLowerCase() === lowerDevice;
+    });
+    if (exact)
+        return exact;
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        const names = matches.map(a => a.deviceInfo.deviceName || a.deviceInfo.title).join(", ");
+        throw new UserInputError(`Multiple devices match "${device}": ${names}. Be more specific (use the full device name for an exact match).`);
+    }
+    if (allOpenNames.length === 0) {
+        throw new UserInputError(`No connected device matches "${device}". No devices are currently connected — run scan_metro to discover and connect to Metro servers.`);
+    }
+    const quoted = allOpenNames.map(n => `"${n}"`).join(", ");
+    throw new UserInputError(`No connected device matches "${device}". Connected devices: ${quoted}. Retry with one of these names (substring match, case-insensitive).`);
+}
+// Check if any app is connected with an OPEN WebSocket
+export function hasConnectedApp() {
+    for (const [, app] of connectedApps.entries()) {
+        if (app.ws.readyState === WebSocket.OPEN) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Run a quick health check to verify the page context is responsive
+ * Returns true if the context can execute code, false otherwise
+ */
+export async function runQuickHealthCheck(app) {
+    const HEALTH_CHECK_TIMEOUT = 2000;
+    const messageId = getNextMessageId();
+    return new Promise((resolve) => {
+        const timeoutId = setTimeout(() => {
+            pendingExecutions.delete(messageId);
+            resolve(false);
+        }, HEALTH_CHECK_TIMEOUT);
+        pendingExecutions.set(messageId, {
+            resolve: (result) => {
+                clearTimeout(timeoutId);
+                pendingExecutions.delete(messageId);
+                // Update context health tracking
+                const appKey = findAppKeyForDevice(app.deviceInfo);
+                if (appKey) {
+                    updateContextHealth(appKey, {
+                        lastHealthCheck: new Date(),
+                        lastHealthCheckSuccess: result.success,
+                        isStale: !result.success,
+                    });
+                }
+                resolve(result.success);
+            },
+            timeoutId,
+        });
+        try {
+            app.ws.send(JSON.stringify({
+                id: messageId,
+                method: "Runtime.evaluate",
+                params: { expression: "1+1", returnByValue: true },
+            }));
+        }
+        catch {
+            clearTimeout(timeoutId);
+            pendingExecutions.delete(messageId);
+            resolve(false);
+        }
+    });
+}
+const LOG_PIPELINE_MARKER_PREFIX = "__rn_devtools_health_";
+/**
+ * Inject a sentinel console.log via CDP and wait for it to appear in the log buffer.
+ * Returns true if the marker arrives within TIMEOUT_MS.
+ */
+async function sendAndWaitForMarker(app, buffer) {
+    const marker = `${LOG_PIPELINE_MARKER_PREFIX}${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const TIMEOUT_MS = 3000;
+    try {
+        app.ws.send(JSON.stringify({
+            id: getNextMessageId(),
+            method: "Runtime.evaluate",
+            params: { expression: `console.log("${marker}")`, returnByValue: true },
+        }));
+    }
+    catch {
+        return false;
+    }
+    // Poll the buffer for the marker (check every 50ms, up to TIMEOUT_MS)
+    const startTime = Date.now();
+    while (Date.now() - startTime < TIMEOUT_MS) {
+        if (buffer.getAll().some(entry => entry.message.includes(marker))) {
+            buffer.removeByText(marker);
+            return true;
+        }
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    return false;
+}
+/**
+ * End-to-end log pipeline verification with automatic recovery.
+ *
+ * 1. Injects a sentinel console.log via CDP and verifies it appears in the buffer.
+ * 2. If the marker doesn't arrive, attempts recovery:
+ *    a. Re-sends Runtime.enable + Log.enable (fixes missing domain subscription)
+ *    b. Retries the marker once
+ * 3. If still broken, force-reconnects via ensureConnection and retries.
+ *
+ * Returns { ok, recovered, message } — the caller decides what to show.
+ */
+export async function verifyLogPipeline(app) {
+    const deviceName = app.deviceInfo.deviceName || app.deviceInfo.title || "unknown";
+    const buffer = getLogBuffer(deviceName);
+    // --- Attempt 1: quick check ---
+    if (await sendAndWaitForMarker(app, buffer)) {
+        return { ok: true, recovered: false, message: null };
+    }
+    // --- Attempt 2: re-enable Runtime/Log domains and retry ---
+    try {
+        app.ws.send(JSON.stringify({ id: getNextMessageId(), method: "Runtime.enable" }));
+        app.ws.send(JSON.stringify({ id: getNextMessageId(), method: "Log.enable" }));
+    }
+    catch {
+        // WS send failed — fall through to reconnect
+    }
+    // Brief pause for domain activation
+    await new Promise(resolve => setTimeout(resolve, 300));
+    if (await sendAndWaitForMarker(app, buffer)) {
+        return { ok: true, recovered: true, message: "[CONNECTION] Log pipeline was stale — re-enabled CDP domains. Logs are flowing again." };
+    }
+    // --- Attempt 3: force reconnect and retry ---
+    const appKey = `${app.port}-${app.deviceInfo.id}`;
+    const port = app.port;
+    cancelReconnectionTimer(appKey);
+    try {
+        app.ws.close();
+    }
+    catch { /* ignore */ }
+    connectedApps.delete(appKey);
+    const result = await ensureConnection({ port, forceRefresh: false, healthCheck: true });
+    if (!result.connected || !result.healthCheckPassed) {
+        return {
+            ok: false,
+            recovered: false,
+            message: "[CONNECTION] Log pipeline broken and reconnection failed. Ensure the app is running, then call scan_metro.",
+        };
+    }
+    // Wait for the new connection to settle
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Get the fresh app reference after reconnection
+    const freshApp = getFirstConnectedApp();
+    if (!freshApp) {
+        return {
+            ok: false,
+            recovered: false,
+            message: "[CONNECTION] Reconnected but no app available. Call scan_metro.",
+        };
+    }
+    const freshDeviceName = freshApp.deviceInfo.deviceName || freshApp.deviceInfo.title || "unknown";
+    const freshBuffer = getLogBuffer(freshDeviceName);
+    if (await sendAndWaitForMarker(freshApp, freshBuffer)) {
+        return {
+            ok: true,
+            recovered: true,
+            message: "[CONNECTION] Log pipeline was broken — reconnected and verified. Logs are flowing again.",
+        };
+    }
+    return {
+        ok: false,
+        recovered: false,
+        message: "[WARNING] Log pipeline verification failed after reconnection. Console events are not reaching the buffer. Try reload_app or scan_metro.",
+    };
+}
+/**
+ * Check if a log message is a health check marker (for filtering from output).
+ */
+export function isHealthCheckMarker(message) {
+    return message.includes(LOG_PIPELINE_MARKER_PREFIX);
+}
+/**
+ * Find the first available Metro port
+ */
+async function findFirstMetroPort() {
+    const ports = await scanMetroPorts();
+    return ports.length > 0 ? ports[0] : null;
+}
+/**
+ * Ensure a healthy connection to a React Native app
+ * This will verify or establish a connection, optionally running a health check
+ */
+export async function ensureConnection(options = {}) {
+    const { port, healthCheck = true, forceRefresh = false } = options;
+    let wasReconnected = false;
+    // forceRefresh: close every currently-connected app, then fall through to
+    // single-device fresh connect. Full multi-device re-discovery is scan_metro's
+    // job — ensureConnection only fresh-connects one when nothing is open.
+    if (forceRefresh) {
+        for (const { key, app } of getConnectedApps()) {
+            cancelReconnectionTimer(key);
+            try {
+                app.ws.close();
+            }
+            catch { /* ignore */ }
+            connectedApps.delete(key);
+        }
+    }
+    let openApps = getConnectedApps()
+        .filter(a => a.isConnected)
+        .map(a => a.app);
+    // Nothing connected — establish a single-device connection from scratch.
+    if (openApps.length === 0) {
+        const targetPort = port ?? await findFirstMetroPort();
+        if (!targetPort) {
+            return {
+                connected: false,
+                wasReconnected: false,
+                healthCheckPassed: false,
+                connectionInfos: [],
+                error: "No Metro server found. Make sure Metro bundler is running.",
+            };
+        }
+        const devices = await fetchDevices(targetPort);
+        const mainDevice = selectMainDevice(devices);
+        if (!mainDevice) {
+            return {
+                connected: false,
+                wasReconnected: false,
+                healthCheckPassed: false,
+                connectionInfos: [],
+                error: `No debuggable devices found on port ${targetPort}. Make sure the app is running.`,
+            };
+        }
+        try {
+            // Clear any prior reconnection suppression — without this a stale
+            // suppression entry from a previous disconnect_metro keeps the
+            // close-handler from auto-recovering if Metro drops the WS just
+            // after probe.
+            clearReconnectionSuppression();
+            const connectResult = await connectToDevice(mainDevice, targetPort);
+            wasReconnected = true;
+            if (connectResult.includes("stale CDP target")) {
+                return {
+                    connected: false,
+                    wasReconnected: false,
+                    healthCheckPassed: false,
+                    connectionInfos: [],
+                    error: `${connectResult}. The CDP page advertised by Metro is no longer responsive — restart the React Native app, then retry.`,
+                };
+            }
+            // Race window: settle briefly and retry getting the open app list.
+            for (let i = 0; i < 5 && openApps.length === 0; i++) {
+                if (i > 0)
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                openApps = getConnectedApps().filter(a => a.isConnected).map(a => a.app);
+            }
+        }
+        catch (error) {
+            let errorMessage;
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else if (error !== undefined && error !== null) {
+                errorMessage = String(error);
+            }
+            else {
+                errorMessage = "WebSocket connection failed with no error details";
+            }
+            return {
+                connected: false,
+                wasReconnected: false,
+                healthCheckPassed: false,
+                connectionInfos: [],
+                error: `Connection failed: ${errorMessage}`,
+            };
+        }
+    }
+    if (openApps.length === 0) {
+        return {
+            connected: false,
+            wasReconnected: false,
+            healthCheckPassed: false,
+            connectionInfos: [],
+            error: "Connection succeeded but app is not available",
+        };
+    }
+    // Per-device health-check; reconnect failed devices individually so a dead
+    // Android doesn't take down a healthy iOS report and vice versa.
+    const perApp = [];
+    for (const candidate of openApps) {
+        let app = candidate;
+        let healthy = true;
+        if (healthCheck) {
+            healthy = await runQuickHealthCheck(app);
+            if (!healthy && !wasReconnected) {
+                const failedTitle = app.deviceInfo.title;
+                console.error(`[execbro] Health check failed for ${failedTitle}, attempting reconnection...`);
+                const appKey = `${app.port}-${app.deviceInfo.id}`;
+                const appPort = app.port;
+                cancelReconnectionTimer(appKey);
+                try {
+                    app.ws.close();
+                }
+                catch { /* ignore */ }
+                connectedApps.delete(appKey);
+                const devices = await fetchDevices(appPort);
+                const mainDevice = selectMainDevice(devices);
+                if (mainDevice) {
+                    try {
+                        await connectToDevice(mainDevice, appPort);
+                        wasReconnected = true;
+                        const fresh = getConnectedApps()
+                            .filter(a => a.isConnected)
+                            .map(a => a.app);
+                        const replacement = fresh.find(a => a.deviceInfo.id === mainDevice.id);
+                        if (replacement) {
+                            app = replacement;
+                            healthy = await runQuickHealthCheck(app);
+                        }
+                        else {
+                            healthy = false;
+                        }
+                    }
+                    catch {
+                        healthy = false;
+                    }
+                }
+                else {
+                    healthy = false;
+                }
+            }
+        }
+        perApp.push({ app, healthy });
+    }
+    const connectionInfos = perApp.map(({ app, healthy }) => {
+        const appKey = `${app.port}-${app.deviceInfo.id}`;
+        const connectionState = getConnectionState(appKey);
+        const contextHealth = getContextHealth(appKey);
+        let uptime = "unknown";
+        if (connectionState?.lastConnectedTime) {
+            uptime = formatDuration(Date.now() - connectionState.lastConnectedTime.getTime());
+        }
+        return {
+            deviceName: app.deviceInfo.deviceName || app.deviceInfo.title,
+            deviceTitle: app.deviceInfo.title,
+            platform: app.platform,
+            port: app.port,
+            uptime,
+            contextId: contextHealth?.contextId ?? null,
+            healthCheckPassed: healthy,
+        };
+    });
+    const anyOpen = perApp.some(r => r.app.ws.readyState === WebSocket.OPEN);
+    const allHealthy = perApp.every(r => r.healthy);
+    return {
+        connected: anyOpen,
+        wasReconnected,
+        healthCheckPassed: allHealthy,
+        connectionInfos,
+        ...(!anyOpen && {
+            error: "App became unavailable after reconnection attempt. Try running scan_metro then ensure_connection."
+        }),
+    };
+}
+export function getPassiveConnectionStatus(targetAppKey) {
+    if (targetAppKey) {
+        // Check a specific device's connection
+        const app = connectedApps.get(targetAppKey);
+        if (!app || app.ws.readyState !== WebSocket.OPEN) {
+            return { connected: false, needsPing: false, reason: "no_connection" };
+        }
+        const health = getContextHealth(targetAppKey);
+        if (health?.isStale) {
+            return { connected: false, needsPing: false, reason: "context_stale" };
+        }
+        const lastMessage = getLastCDPMessageTime(targetAppKey);
+        if (!lastMessage) {
+            return { connected: false, needsPing: false, reason: "no_activity" };
+        }
+        const elapsed = Date.now() - lastMessage.getTime();
+        if (elapsed > STALE_ACTIVITY_THRESHOLD_MS) {
+            return { connected: true, needsPing: true, reason: "activity_stale" };
+        }
+        return { connected: true, needsPing: false, reason: "ok" };
+    }
+    // Default: check first connected app (backwards compatible)
+    if (!hasConnectedApp()) {
+        return { connected: false, needsPing: false, reason: "no_connection" };
+    }
+    const app = getFirstConnectedApp();
+    if (app) {
+        const appKey = `${app.port}-${app.deviceInfo.id}`;
+        const health = getContextHealth(appKey);
+        if (health?.isStale) {
+            return { connected: false, needsPing: false, reason: "context_stale" };
+        }
+    }
+    const lastMessage = getLastCDPMessageTime();
+    if (!lastMessage) {
+        return { connected: false, needsPing: false, reason: "no_activity" };
+    }
+    const elapsed = Date.now() - lastMessage.getTime();
+    if (elapsed > STALE_ACTIVITY_THRESHOLD_MS) {
+        return { connected: true, needsPing: true, reason: "activity_stale" };
+    }
+    return { connected: true, needsPing: false, reason: "ok" };
+}
+export async function checkAndEnsureConnection(device) {
+    // Resolve targeted device to appKey if specified
+    let targetAppKey;
+    let targetApp = null;
+    if (device) {
+        try {
+            targetApp = getConnectedAppByDevice(device);
+            if (targetApp) {
+                targetAppKey = `${targetApp.port}-${targetApp.deviceInfo.id}`;
+            }
+        }
+        catch {
+            // Device not found — fall through to reconnection
+        }
+    }
+    const passive = getPassiveConnectionStatus(targetAppKey);
+    if (passive.connected && !passive.needsPing) {
+        return { connected: true, wasReconnected: false, message: null };
+    }
+    if (passive.connected && passive.needsPing) {
+        const app = targetApp ?? getFirstConnectedApp();
+        if (app) {
+            const healthy = await runQuickHealthCheck(app);
+            if (healthy) {
+                return { connected: true, wasReconnected: false, message: null };
+            }
+        }
+    }
+    const result = await ensureConnection({ forceRefresh: true, healthCheck: true });
+    if (result.connected && result.healthCheckPassed) {
+        await new Promise(resolve => setTimeout(resolve, RECONNECT_SETTLE_MS));
+        return {
+            connected: true,
+            wasReconnected: true,
+            message: "[CONNECTION] Was stale, re-established. Earlier data may be incomplete; new data will appear on next call.",
+        };
+    }
+    return {
+        connected: false,
+        wasReconnected: false,
+        message: "[CONNECTION] No active connection. Could not reconnect. Ensure Metro and the app are running, then call scan_metro.",
+    };
+}
+//# sourceMappingURL=connection.js.map