react-native-ai-debugger 1.1.4 → 1.4.21

package/build/core/connection.js

@@ -1,11 +1,15 @@
 import WebSocket from "ws";
-import { connectedApps, pendingExecutions, getNextMessageId, logBuffer, networkBuffer, setActiveSimulatorUdid, clearActiveSimulatorIfSource, updateLastCDPMessageTime, getLastCDPMessageTime } from "./state.js";
+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 { fetchDevices, selectMainDevice, scanMetroPorts } from "./metro.js";
+import { scheduleAppDetection } from "./appDetection.js";
 import { DEFAULT_RECONNECTION_CONFIG, MIN_STABLE_CONNECTION_MS, initConnectionState, updateConnectionState, getConnectionState, recordConnectionGap, closeConnectionGap, saveConnectionMetadata, getConnectionMetadata, saveReconnectionTimer, cancelReconnectionTimer, calculateBackoffDelay, initContextHealth, markContextHealthy, markContextStale, getContextHealth, updateContextHealth, formatDuration, } 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();
 // Suppress auto-reconnection for intentionally disconnected devices
 const reconnectionSuppressed = new Set();
 /**
@@ -17,6 +21,13 @@ export function suppressReconnection() {
         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).
  */
@@ -24,7 +35,76 @@ export function clearReconnectionSuppression() {
     reconnectionSuppressed.clear();
 }
 const STALE_ACTIVITY_THRESHOLD_MS = 30_000;
+const PING_INTERVAL_MS = 1_000; // WebSocket ping/pong keepalive interval
 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("[rn-ai-debugger] 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("[rn-ai-debugger] 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(`[rn-ai-debugger] 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()) {
@@ -44,6 +124,47 @@ function getWebSocketStateName(state) {
         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(`[rn-ai-debugger] 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") {
@@ -159,6 +280,10 @@ function formatPreview(preview) {
 }
 // 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);
@@ -175,7 +300,11 @@ function formatConsoleArg(arg) {
     if (arg.description) {
         return arg.description;
     }
-    return "[object]";
+    // 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) {
@@ -294,9 +423,13 @@ async function resolveConsoleArgs(ws, args) {
     return parts.join(" ");
 }
 // Handle CDP messages
-export function handleCDPMessage(message, _device, ws) {
-    // Track last CDP activity for connection liveness detection
-    updateLastCDPMessageTime(new Date());
+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);
@@ -332,6 +465,24 @@ export function handleCDPMessage(message, _device, ws) {
             }
             pending.resolve({ success: true, result: "undefined" });
         }
+        // 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(`[rn-ai-debugger] CDP Network domain not supported, using JS interceptor`);
+                    }
+                    else {
+                        app.cdpNetworkSupported = true;
+                        console.error(`[rn-ai-debugger] CDP Network domain supported`);
+                    }
+                }
+            }
+        }
         return;
     }
     const method = message.method;
@@ -341,36 +492,42 @@ export function handleCDPMessage(message, _device, ws) {
         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;
+            if (!iApp?.cdpNetworkSupported) {
+                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) => {
-                if (messageText.trim()) {
-                    logBuffer.add({
-                        timestamp: new Date(),
-                        level,
-                        message: messageText,
-                        args: args.map((a) => a.value)
-                    });
-                }
+                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(" ");
-                if (messageText.trim()) {
-                    logBuffer.add({
-                        timestamp: new Date(),
-                        level,
-                        message: messageText,
-                        args: args.map((a) => a.value)
-                    });
-                }
+                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()) {
-                logBuffer.add({
+                getLogBuffer(deviceName).add({
                     timestamp: new Date(),
                     level,
                     message: messageText,
@@ -384,7 +541,7 @@ export function handleCDPMessage(message, _device, ws) {
         const params = message.params;
         if (params.entry) {
             const level = mapConsoleType(params.entry.level || "log");
-            logBuffer.add({
+            getLogBuffer(deviceName).add({
                 timestamp: new Date(),
                 level,
                 message: params.entry.text || ""
@@ -406,12 +563,12 @@ export function handleCDPMessage(message, _device, ws) {
             },
             completed: false
         };
-        networkBuffer.set(params.requestId, request);
+        getNetworkBuffer(deviceName).set(params.requestId, request);
     }
     // Handle Network.responseReceived
     if (method === "Network.responseReceived") {
         const params = message.params;
-        const existing = networkBuffer.get(params.requestId);
+        const existing = getNetworkBuffer(deviceName).get(params.requestId);
         if (existing) {
             existing.status = params.response.status;
             existing.statusText = params.response.statusText;
@@ -420,40 +577,47 @@ export function handleCDPMessage(message, _device, ws) {
             if (params.timestamp && existing.timing?.requestTime) {
                 existing.timing.responseTime = params.timestamp;
             }
-            networkBuffer.set(params.requestId, existing);
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
         }
     }
     // Handle Network.loadingFinished
     if (method === "Network.loadingFinished") {
         const params = message.params;
-        const existing = networkBuffer.get(params.requestId);
+        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);
             }
-            networkBuffer.set(params.requestId, existing);
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
         }
     }
     // Handle Network.loadingFailed
     if (method === "Network.loadingFailed") {
         const params = message.params;
-        const existing = networkBuffer.get(params.requestId);
+        const existing = getNetworkBuffer(deviceName).get(params.requestId);
         if (existing) {
             existing.completed = true;
             existing.error = params.canceled ? "Canceled" : (params.errorText || "Request failed");
-            networkBuffer.set(params.requestId, existing);
+            getNetworkBuffer(deviceName).set(params.requestId, existing);
         }
     }
     // Handle Runtime context lifecycle events for health tracking
-    const appKey = findAppKeyForDevice(_device);
+    const appKey = findAppKeyForDevice(device);
     if (appKey) {
         // Handle Runtime.executionContextCreated
         if (method === "Runtime.executionContextCreated") {
             const params = message.params;
             markContextHealthy(appKey, params.context.id);
             console.error(`[rn-ai-debugger] 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);
+            }
         }
         // Handle Runtime.executionContextDestroyed
         if (method === "Runtime.executionContextDestroyed") {
@@ -470,18 +634,61 @@ export function handleCDPMessage(message, _device, ws) {
 // 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((resolve, reject) => {
+    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) {
-                resolve(`Already connected to ${device.title}`);
-                return;
+                // 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(`[rn-ai-debugger] Existing connection to ${device.title} failed liveness check (no pong), reconnecting`);
+                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(`[rn-ai-debugger] 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;
+                }
             }
-            // WebSocket exists but not OPEN - clean up stale entry
-            console.error(`[rn-ai-debugger] Cleaning up stale connection for ${device.title} (state: ${getWebSocketStateName(existingApp.ws.readyState)})`);
-            connectedApps.delete(appKey);
         }
         // Prevent concurrent connection attempts to the same device
         if (connectionLocks.has(appKey)) {
@@ -498,60 +705,79 @@ export async function connectToDevice(device, port, options = {}) {
             webSocketUrl: device.webSocketDebuggerUrl
         });
         try {
-            const ws = new WebSocket(device.webSocketDebuggerUrl);
-            ws.on("open", async () => {
-                // Release connection lock
-                connectionLocks.delete(appKey);
-                connectedApps.set(appKey, { ws, deviceInfo: device, port, platform: "android" });
-                // 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(`[rn-ai-debugger] Reconnected to ${device.title}`);
-                }
-                else {
-                    initConnectionState(appKey);
-                    initContextHealth(appKey);
-                    console.error(`[rn-ai-debugger] Connected to ${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"
-                }));
-                // Enable Network domain to track requests
-                ws.send(JSON.stringify({
-                    id: getNextMessageId(),
-                    method: "Network.enable"
-                }));
-                // Try to resolve iOS simulator UDID from device name
-                // This enables automatic device scoping for iOS tools
-                if (device.deviceName) {
-                    const simulatorUdid = await findSimulatorByName(device.deviceName);
-                    if (simulatorUdid) {
-                        setActiveSimulatorUdid(simulatorUdid, appKey);
-                        // Update platform to ios now that simulator is confirmed
-                        const connectedApp = connectedApps.get(appKey);
-                        if (connectedApp) {
-                            connectedApp.platform = "ios";
-                        }
-                        console.error(`[rn-ai-debugger] Linked to iOS simulator: ${simulatorUdid}`);
+            const ws = await createWebSocketWithOriginFallback(device.webSocketDebuggerUrl);
+            // Connection established — run setup
+            connectionLocks.delete(appKey);
+            connectedApps.set(appKey, { ws, deviceInfo: device, port, platform: "android" });
+            // 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(`[rn-ai-debugger] Reconnected to ${device.title}`);
+            }
+            else {
+                initConnectionState(appKey);
+                initContextHealth(appKey);
+                console.error(`[rn-ai-debugger] Connected to ${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);
+            // Try to resolve iOS simulator UDID from device name
+            // This enables automatic device scoping for iOS tools
+            if (device.deviceName) {
+                const simulatorUdid = await findSimulatorByName(device.deviceName);
+                if (simulatorUdid) {
+                    setActiveSimulatorUdid(simulatorUdid, appKey);
+                    // Update platform to ios now that simulator is confirmed
+                    const connectedApp = connectedApps.get(appKey);
+                    if (connectedApp) {
+                        connectedApp.platform = "ios";
+                        connectedApp.simulatorUdid = simulatorUdid;
                     }
+                    console.error(`[rn-ai-debugger] Linked to iOS simulator: ${simulatorUdid}`);
                 }
-                resolve(`Connected to ${device.title} (${device.deviceName})`);
+            }
+            // Fire-and-forget app detection (500ms delayed, non-blocking)
+            const appForDetection = connectedApps.get(appKey);
+            if (appForDetection) {
+                scheduleAppDetection(appForDetection);
+            }
+            // Start WebSocket ping/pong keepalive to detect dead connections
+            // (especially important for physical devices over Wi-Fi)
+            let pongReceived = true;
+            const pingInterval = setInterval(() => {
+                if (!pongReceived) {
+                    console.error(`[rn-ai-debugger] No pong from ${device.title}, terminating connection`);
+                    clearInterval(pingInterval);
+                    ws.terminate();
+                    return;
+                }
+                pongReceived = false;
+                ws.ping();
+            }, PING_INTERVAL_MS);
+            ws.on("pong", () => {
+                pongReceived = true;
             });
             ws.on("message", (data) => {
                 try {
@@ -563,11 +789,15 @@ export async function connectToDevice(device, port, options = {}) {
                 }
             });
             ws.on("close", () => {
+                clearInterval(pingInterval);
                 // 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;
@@ -597,41 +827,23 @@ export async function connectToDevice(device, port, options = {}) {
                 }
             });
             ws.on("error", (error) => {
-                // Release connection lock
-                connectionLocks.delete(appKey);
-                // Cancel any pending reconnection timer to prevent orphaned loops
-                cancelReconnectionTimer(appKey);
-                connectedApps.delete(appKey);
-                // Clear active simulator UDID if this connection set it
-                clearActiveSimulatorIfSource(appKey);
-                // Extract error message safely - some WebSocket errors may not have a message
-                const errorMsg = error?.message || error?.toString() || 'Unknown WebSocket error';
-                // Only reject if this is initial connection, not reconnection attempt
-                if (!isReconnection) {
-                    reject(`Failed to connect to ${device.title}: ${errorMsg}`);
-                }
-                else {
-                    console.error(`[rn-ai-debugger] Reconnection error: ${errorMsg}`);
-                }
+                console.error(`[rn-ai-debugger] WebSocket error for ${device.title}: ${error?.message || error}`);
             });
-            // Timeout after 5 seconds
-            setTimeout(() => {
-                if (ws.readyState !== WebSocket.OPEN) {
-                    // Release connection lock on timeout
-                    connectionLocks.delete(appKey);
-                    ws.terminate();
-                    if (!isReconnection) {
-                        reject(`Connection to ${device.title} timed out`);
-                    }
-                }
-            }, 5000);
+            resolve(`Connected to ${device.title} (${device.deviceName})`);
         }
         catch (error) {
-            // Release connection lock on exception
+            // 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) {
-                const errorMessage = error instanceof Error ? error.message : (error ? String(error) : "Unknown error");
-                reject(`Failed to create WebSocket connection: ${errorMessage}`);
+                reject(`Failed to connect to ${device.title}: ${errorMsg}`);
+            }
+            else {
+                console.error(`[rn-ai-debugger] Reconnection error: ${errorMsg}`);
             }
         }
     });
@@ -669,6 +881,14 @@ async function attemptReconnection(appKey, config = DEFAULT_RECONNECTION_CONFIG)
         console.error(`[rn-ai-debugger] No metadata for reconnection: ${appKey}`);
         return false;
     }
+    // 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(`[rn-ai-debugger] Metro not running on port ${metadata.port}, stopping reconnection for ${appKey}`);
+        updateConnectionState(appKey, { status: "disconnected" });
+        return false;
+    }
     try {
         // Re-fetch devices to get fresh WebSocket URL (may have changed)
         const devices = await fetchDevices(metadata.port);
@@ -712,6 +932,31 @@ export function getFirstConnectedApp() {
     }
     return null;
 }
+export function getConnectedAppByDevice(device) {
+    if (!device) {
+        return getFirstConnectedApp();
+    }
+    const lowerDevice = device.toLowerCase();
+    const matches = [];
+    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 || "";
+        if (deviceName.toLowerCase().includes(lowerDevice)) {
+            matches.push(app);
+        }
+    }
+    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 Error(`Multiple devices match "${device}": ${names}. Be more specific.`);
+    }
+    throw new Error(`No connected device matches "${device}". Run get_apps to see available devices.`);
+}
 // Check if any app is connected with an OPEN WebSocket
 export function hasConnectedApp() {
     for (const [, app] of connectedApps.entries()) {
@@ -764,6 +1009,115 @@ export async function runQuickHealthCheck(app) {
         }
     });
 }
+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
  */
@@ -897,8 +1251,9 @@ export async function ensureConnection(options = {}) {
         const uptimeMs = Date.now() - connectionState.lastConnectedTime.getTime();
         uptime = formatDuration(uptimeMs);
     }
+    const isConnected = app !== null && app.ws.readyState === WebSocket.OPEN;
     return {
-        connected: app !== null && app.ws.readyState === WebSocket.OPEN,
+        connected: isConnected,
         wasReconnected,
         healthCheckPassed,
         connectionInfo: app ? {
@@ -907,9 +1262,35 @@ export async function ensureConnection(options = {}) {
             uptime,
             contextId: contextHealth?.contextId ?? null,
         } : null,
+        ...(!isConnected && {
+            error: app
+                ? `Connection lost: WebSocket is in ${["CONNECTING", "OPEN", "CLOSING", "CLOSED"][app.ws.readyState] || "unknown"} state (expected OPEN). Health check ${healthCheckPassed ? "passed" : "failed"}. Try ensure_connection with forceRefresh=true.`
+                : "App became unavailable after reconnection attempt. Try running scan_metro then ensure_connection."
+        }),
     };
 }
-export function getPassiveConnectionStatus() {
+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" };
     }
@@ -931,13 +1312,27 @@ export function getPassiveConnectionStatus() {
     }
     return { connected: true, needsPing: false, reason: "ok" };
 }
-export async function checkAndEnsureConnection() {
-    const passive = getPassiveConnectionStatus();
+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 = getFirstConnectedApp();
+        const app = targetApp ?? getFirstConnectedApp();
         if (app) {
             const healthy = await runQuickHealthCheck(app);
             if (healthy) {