react-native-ai-devtools 1.4.12 → 1.4.14

package/build/core/connection.js

@@ -1,5 +1,5 @@
 import WebSocket from "ws";
-import { connectedApps, pendingExecutions, getNextMessageId, getLogBuffer, getNetworkBuffer, 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";
@@ -37,6 +37,74 @@ export function clearReconnectionSuppression() {
 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()) {
@@ -171,6 +239,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);
@@ -187,7 +259,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) {
@@ -307,8 +383,11 @@ async function resolveConsoleArgs(ws, args) {
 }
 // Handle CDP messages
 export function handleCDPMessage(message, device, ws) {
-    // Track last CDP activity for connection liveness detection
-    updateLastCDPMessageTime(new Date());
+    // 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") {
@@ -387,25 +466,21 @@ export function handleCDPMessage(message, device, ws) {
         if (hasObjectArgs) {
             // Resolve object args asynchronously via CDP
             resolveConsoleArgs(ws, args).then((messageText) => {
-                if (messageText.trim()) {
-                    getLogBuffer(deviceName).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()) {
-                    getLogBuffer(deviceName).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 {
@@ -518,7 +593,7 @@ 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);
@@ -558,88 +633,79 @@ export async function connectToDevice(device, port, options = {}) {
             webSocketUrl: device.webSocketDebuggerUrl
         });
         try {
-            // Metro requires a valid Origin header matching the server's host
-            const wsUrl = new URL(device.webSocketDebuggerUrl);
-            const origin = `http://${wsUrl.hostname}:${wsUrl.port}`;
-            const ws = new WebSocket(device.webSocketDebuggerUrl, { headers: { Origin: origin } });
-            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"
-                }));
-                // 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}`);
+            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}`);
                 }
-                // 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("close", () => {
+            }
+            // 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);
-                });
-                resolve(`Connected to ${device.title} (${device.deviceName})`);
+                    ws.terminate();
+                    return;
+                }
+                pongReceived = false;
+                ws.ping();
+            }, PING_INTERVAL_MS);
+            ws.on("pong", () => {
+                pongReceived = true;
             });
             ws.on("message", (data) => {
                 try {
@@ -651,9 +717,11 @@ 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
@@ -687,41 +755,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}`);
             }
         }
     });
@@ -887,6 +937,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
  */
@@ -1038,7 +1197,28 @@ export async function ensureConnection(options = {}) {
         }),
     };
 }
-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" };
     }
@@ -1060,13 +1240,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) {