@houwert/conductor 0.12.3 → 0.13.0

package/dist/daemon/log-collector.js

@@ -12,41 +12,36 @@ exports.LogCollector = void 0;
  * simctl / adb logcat). For web, polls the co-located web-server's
  * /consoleLogs endpoint.
  *
- * Optionally discovers and connects to a Metro dev server for React Native
- * JS-level console logs. This is opt-in: call enableMetro(port) to start
- * background discovery. Metro entries are merged into the same buffer with
- * source='metro'.
+ * Also deterministically detects whether this device is connected to a Metro
+ * dev server and, if so, connects to it. Metro entries are merged into the
+ * same buffer with source='metro'. Discovery is automatic — callers do not
+ * pass a port.
+ *
+ * iOS/tvOS discovery: locate PIDs running inside the simulator via
+ *   `xcrun simctl spawn <UDID> launchctl list`, then `lsof` each PID for
+ *   ESTABLISHED TCP connections to a Metro port on localhost. The remote
+ *   port is the Metro port for this specific simulator.
+ * Android discovery: `adb -s <serial> reverse --list` for forwarded Metro
+ *   ports — already device-scoped.
+ * Target selection: Metro's /json exposes `deviceName` (e.g. the simulator
+ *   display name, or Android Build.MODEL). We resolve the device's display
+ *   name from its UDID/serial and filter targets to only those matching —
+ *   this disambiguates multiple devices sharing a single Metro instance.
  */
 const http_1 = __importDefault(require("http"));
-const child_process_1 = require("child_process");
 const types_js_1 = require("../drivers/log-sources/types.js");
 const ios_js_1 = require("../drivers/log-sources/ios.js");
 const android_js_1 = require("../drivers/log-sources/android.js");
 const metro_js_1 = require("../drivers/log-sources/metro.js");
+const metro_discovery_js_1 = require("../drivers/log-sources/metro-discovery.js");
 const MAX_BUFFER = 5000;
 const RESTART_DELAY_MS = 2000;
 const WEB_POLL_INTERVAL_MS = 500;
-const METRO_DISCOVERY_INTERVAL_MS = 3000;
-const METRO_AUTO_DISCOVERY_MAX_ATTEMPTS = 10;
-/** Known Metro dev server port ranges. */
-const METRO_PORT_RANGES = [
-    [8080, 8099], // Metro default range
-    [19000, 19002], // Expo
-];
-function isMetroPort(port) {
-    return METRO_PORT_RANGES.some(([lo, hi]) => port >= lo && port <= hi);
-}
-function spawnCapture(cmd, args) {
-    return new Promise((resolve, reject) => {
-        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
-        let out = '';
-        proc.stdout?.on('data', (chunk) => {
-            out += chunk.toString();
-        });
-        proc.on('close', (code) => code === 0 ? resolve(out) : reject(new Error(`${cmd} failed (${code})`)));
-        proc.on('error', reject);
-    });
-}
+// Metro discovery retries forever while the daemon is alive — the app may be
+// launched long after the daemon starts. Backoff grows to a ceiling so we're
+// not wasteful when discovery keeps failing (e.g. native-only app).
+const METRO_DISCOVERY_MIN_INTERVAL_MS = 1500;
+const METRO_DISCOVERY_MAX_INTERVAL_MS = 15000;
 class LogCollector {
     constructor(platform, deviceId, driverPort, appId, dlog) {
         this.platform = platform;
@@ -66,8 +61,9 @@ class LogCollector {
         this.metroDiscoveryTimer = null;
         this.metroPort = null;
         this.metroConnected = false;
-        this.metroAutoDiscovery = false;
-        this.metroAutoDiscoveryAttempts = 0;
+        this.metroDiscoveryAttempts = 0;
+        this.cachedDeviceName = null;
+        this.lastAnnouncedState = 'none';
     }
     async start() {
         this.stopped = false;
@@ -76,6 +72,12 @@ class LogCollector {
             return;
         }
         await this.startSource();
+        // Metro is always auto-discovered. Discovery retries forever with a
+        // backoff ceiling — the app may be launched long after the daemon starts,
+        // and the cost per attempt is tiny (a few spawns + one HTTP call).
+        if (this.platform === 'ios' || this.platform === 'tvos' || this.platform === 'android') {
+            this.startMetroAutoDiscovery();
+        }
     }
     stop() {
         this.stopped = true;
@@ -101,39 +103,6 @@ class LogCollector {
             this.metroConnected = false;
         }
     }
-    /**
-     * Enable Metro log collection for React Native apps.
-     *
-     * When `port` is given, connects directly to that Metro port.
-     * When omitted, auto-discovers the Metro port by probing the device:
-     *   - Android: parses `adb reverse --list` for forwarded Metro ports
-     *   - iOS/tvOS: scans `lsof` for node listeners in Metro port ranges,
-     *     then probes `/json` and matches by deviceId (strict — no appId fallback)
-     *
-     * This is opt-in — only call this for React Native apps.
-     */
-    enableMetro(port) {
-        if (this.platform === 'web')
-            return; // Web already has console logs
-        if (port !== undefined) {
-            // Explicit port — same as before
-            if (this.metroPort === port)
-                return;
-            this.teardownMetro();
-            this.metroAutoDiscovery = false;
-            this.metroPort = port;
-            this.startMetroDiscovery();
-        }
-        else {
-            // Auto-discover
-            if (this.metroAutoDiscovery || this.metroConnected)
-                return;
-            this.teardownMetro();
-            this.metroAutoDiscovery = true;
-            this.metroAutoDiscoveryAttempts = 0;
-            this.startAutoDiscovery();
-        }
-    }
     teardownMetro() {
         if (this.metroSource) {
             this.metroSource.disconnect();
@@ -241,168 +210,92 @@ class LogCollector {
             req.on('error', reject);
         });
     }
-    // ── Metro auto-discovery ─────────────────────────────────────────────────
-    async startAutoDiscovery() {
+    // ── Metro auto-discovery (deterministic) ─────────────────────────────────
+    startMetroAutoDiscovery() {
         if (this.stopped || this.metroConnected)
             return;
-        this.metroAutoDiscoveryAttempts++;
+        void this.tryDiscoverAndConnect();
+    }
+    async tryDiscoverAndConnect() {
+        if (this.stopped || this.metroConnected)
+            return;
+        this.metroDiscoveryAttempts++;
         try {
-            const port = await this.discoverMetroPort();
+            const port = await (0, metro_discovery_js_1.discoverMetroPortForDevice)(this.platform, this.deviceId);
             if (port !== null) {
-                this.dlog?.(`Metro auto-discovered on port ${port} for device ${this.deviceId}`);
-                this.metroPort = port;
-                this.startMetroDiscovery();
-                return;
+                const connected = await this.connectMetro(port);
+                if (connected)
+                    return;
             }
         }
         catch {
-            // Discovery failed — retry
+            // fall through to retry
         }
-        if (this.metroAutoDiscoveryAttempts >= METRO_AUTO_DISCOVERY_MAX_ATTEMPTS) {
-            this.dlog?.(`Metro auto-discovery: no Metro instance found for device ${this.deviceId} after ${this.metroAutoDiscoveryAttempts} attempts. Use --metro-port to specify.`);
-            this.metroAutoDiscovery = false;
-            return;
+        // Announce "searching" exactly once so callers can tell discovery is live.
+        if (this.lastAnnouncedState === 'none' && this.metroDiscoveryAttempts >= 3) {
+            this.lastAnnouncedState = 'searching';
+            this.pushSyntheticMetroEntry(`[conductor] Searching for Metro connection on device ${this.deviceId}… (this is normal for native apps — ignore if not using React Native)`);
         }
-        // Retry — app may not have started yet
         if (!this.stopped) {
+            const delay = Math.min(METRO_DISCOVERY_MIN_INTERVAL_MS * Math.pow(1.5, this.metroDiscoveryAttempts - 1), METRO_DISCOVERY_MAX_INTERVAL_MS);
             this.metroDiscoveryTimer = setTimeout(() => {
                 this.metroDiscoveryTimer = null;
-                this.startAutoDiscovery();
-            }, METRO_DISCOVERY_INTERVAL_MS);
+                void this.tryDiscoverAndConnect();
+            }, delay);
         }
     }
     /**
-     * Discover the Metro dev server port by probing the device.
-     *
-     * Android: parse `adb reverse --list` for forwarded ports in Metro ranges.
-     * iOS/tvOS: scan `lsof` for node listeners in Metro ranges, probe `/json`,
-     * and strictly match by deviceId (no appId/single-target fallback).
+     * Push a synthetic log entry into the buffer so that Metro connection state
+     * is visible to anyone reading the log stream.
      */
-    async discoverMetroPort() {
-        if (this.platform === 'android') {
-            return this.discoverMetroPortAndroid();
-        }
-        if (this.platform === 'ios' || this.platform === 'tvos') {
-            return this.discoverMetroPortIOS();
-        }
-        return null;
-    }
-    async discoverMetroPortAndroid() {
-        try {
-            const output = await spawnCapture('adb', ['-s', this.deviceId, 'reverse', '--list']);
-            // Lines look like: host-13 tcp:8082 tcp:8082
-            for (const line of output.split('\n')) {
-                const match = line.match(/tcp:(\d+)\s+tcp:(\d+)/);
-                if (!match)
-                    continue;
-                const hostPort = parseInt(match[2], 10);
-                if (isMetroPort(hostPort))
-                    return hostPort;
-            }
-        }
-        catch {
-            // adb not available or device not connected
-        }
-        return null;
-    }
-    async discoverMetroPortIOS() {
-        try {
-            const output = await spawnCapture('lsof', ['-iTCP', '-sTCP:LISTEN', '-n', '-P']);
-            const ports = new Set();
-            for (const line of output.split('\n')) {
-                if (!line.startsWith('node'))
-                    continue;
-                // Column 9 is NAME, e.g. "*:8082" or "[::1]:8082" or "127.0.0.1:8082"
-                const match = line.match(/:(\d+)\s/);
-                if (!match)
-                    continue;
-                const port = parseInt(match[1], 10);
-                if (isMetroPort(port))
-                    ports.add(port);
-            }
-            if (ports.size === 0)
-                return null;
-            // Probe all candidate ports in parallel
-            const results = await Promise.all([...ports].map(async (port) => {
-                try {
-                    const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
-                    const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
-                    // Strict deviceId match only — no appId or single-target fallback
-                    const match = withWs.find((t) => t.deviceId === this.deviceId || t.reactNative?.logicalDeviceId === this.deviceId);
-                    return match ? port : null;
-                }
-                catch {
-                    return null;
-                }
-            }));
-            return results.find((p) => p !== null) ?? null;
-        }
-        catch {
-            // lsof not available
-        }
-        return null;
+    pushSyntheticMetroEntry(message) {
+        this.pushEntry({
+            timestamp: new Date().toISOString(),
+            level: 'info',
+            message,
+            stackTrace: null,
+            source: 'metro',
+        });
     }
-    startMetroDiscovery() {
-        if (this.stopped || this.metroPort === null)
-            return;
-        this.tryConnectMetro();
+    /** Metro connection state for the /status endpoint. */
+    getMetroStatus() {
+        return {
+            connected: this.metroConnected,
+            port: this.metroPort,
+            attempts: this.metroDiscoveryAttempts,
+        };
     }
-    async tryConnectMetro() {
-        if (this.stopped || this.metroPort === null || this.metroConnected)
-            return;
+    /**
+     * Connect to Metro on the given port, picking the target matching this
+     * device's display name. Returns true on success.
+     */
+    async connectMetro(port) {
+        if (this.stopped || this.metroConnected)
+            return false;
         try {
-            const targets = await (0, metro_js_1.fetchTargets)(this.metroPort, 'localhost');
-            const target = this.findTargetForDevice(targets);
-            if (!target || !target.webSocketDebuggerUrl) {
-                // Target not found yet — app may still be starting. Retry later.
-                this.scheduleMetroDiscovery();
-                return;
-            }
-            // Found a matching target — connect
-            const targetIndex = targets.filter((t) => t.webSocketDebuggerUrl).indexOf(target);
-            this.metroSource = new metro_js_1.MetroLogSource(this.metroPort, 'localhost', targetIndex >= 0 ? targetIndex : undefined);
+            const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+            const displayName = this.cachedDeviceName ?? (await (0, metro_discovery_js_1.getDeviceDisplayName)(this.platform, this.deviceId));
+            if (!displayName)
+                return false;
+            this.cachedDeviceName = displayName;
+            const target = (0, metro_discovery_js_1.selectTargetForDevice)(targets, displayName);
+            if (!target?.webSocketDebuggerUrl)
+                return false;
+            const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
+            const targetIndex = withWs.indexOf(target);
+            this.metroSource = new metro_js_1.MetroLogSource(port, 'localhost', targetIndex >= 0 ? targetIndex : undefined);
             this.metroSource.onEntry((entry) => this.pushEntry(entry));
             await this.metroSource.connect();
             this.metroConnected = true;
-            this.dlog?.(`Metro connected for device ${this.deviceId} on port ${this.metroPort}`);
+            this.metroPort = port;
+            this.lastAnnouncedState = 'connected';
+            this.pushSyntheticMetroEntry(`[conductor] Metro connected on port ${port} for device "${displayName}"`);
+            this.dlog?.(`Metro connected for device ${this.deviceId} on port ${port}`);
+            return true;
         }
         catch {
-            // Metro not running or connection failed — retry
-            this.scheduleMetroDiscovery();
+            return false;
         }
     }
-    /**
-     * Find a Metro debugger target that matches this daemon's device.
-     * Checks deviceId (simulator UDID / emulator serial) first,
-     * then falls back to matching by appId if available.
-     */
-    findTargetForDevice(targets) {
-        const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
-        if (withWs.length === 0)
-            return undefined;
-        // Prefer exact deviceId match (simulator UDID / emulator serial)
-        const byDevice = withWs.find((t) => t.deviceId === this.deviceId || t.reactNative?.logicalDeviceId === this.deviceId);
-        if (byDevice)
-            return byDevice;
-        // Fall back to appId match if we know the app
-        if (this.appId) {
-            const byApp = withWs.find((t) => t.appId === this.appId);
-            if (byApp)
-                return byApp;
-        }
-        // Single target — safe to use without matching
-        if (withWs.length === 1)
-            return withWs[0];
-        // Multiple targets, no match — don't guess
-        return undefined;
-    }
-    scheduleMetroDiscovery() {
-        if (this.stopped || this.metroConnected)
-            return;
-        this.metroDiscoveryTimer = setTimeout(() => {
-            this.metroDiscoveryTimer = null;
-            this.tryConnectMetro();
-        }, METRO_DISCOVERY_INTERVAL_MS);
-    }
 }
 exports.LogCollector = LogCollector;

package/dist/daemon/server.js

@@ -288,6 +288,7 @@ async function main() {
                 chromiumCdpPort: driverPlatform === 'web' ? (0, web_server_js_1.getCdpPort)() : null,
                 pageTargetId: driverPlatform === 'web' ? (0, web_server_js_1.getPageTargetId)() : null,
                 driverStartError: _driverStartError,
+                metro: logCollector?.getMetroStatus() ?? null,
             });
             return;
         }
@@ -297,17 +298,6 @@ async function main() {
                 return;
             }
             const q = parsed.query;
-            // Opt-in Metro discovery: ?metro=8081 uses that port directly,
-            // ?metro (no value) or ?metro=auto triggers auto-discovery.
-            if (q.metro !== undefined) {
-                const metroPort = typeof q.metro === 'string' ? parseInt(q.metro, 10) : NaN;
-                if (metroPort > 0) {
-                    logCollector.enableMetro(metroPort);
-                }
-                else {
-                    logCollector.enableMetro(); // auto-discover
-                }
-            }
             const entries = logCollector.query({
                 since: typeof q.since === 'string' ? q.since : undefined,
                 level: typeof q.level === 'string' ? q.level : undefined,

package/dist/drivers/log-sources/daemon.js

@@ -14,14 +14,12 @@ const http_1 = __importDefault(require("http"));
 const protocol_js_1 = require("../../daemon/protocol.js");
 const POLL_INTERVAL_MS = 500;
 class DaemonLogSource {
-    constructor(sessionName, metroPort) {
+    constructor(sessionName) {
         this.sessionName = sessionName;
-        this.metroPort = metroPort;
         this.callback = null;
         this.pollTimer = null;
         this.since = new Date().toISOString();
         this.stopped = false;
-        this.metroSent = false;
         this.sockPath = (0, protocol_js_1.socketPath)(sessionName);
     }
     async connect() {
@@ -65,12 +63,7 @@ class DaemonLogSource {
         poll();
     }
     fetchLogs() {
-        // Include metro param on the first poll to trigger discovery in the daemon
-        let reqPath = `/logs?since=${encodeURIComponent(this.since)}`;
-        if (this.metroPort !== undefined && !this.metroSent) {
-            reqPath += this.metroPort === 'auto' ? '&metro' : `&metro=${this.metroPort}`;
-            this.metroSent = true;
-        }
+        const reqPath = `/logs?since=${encodeURIComponent(this.since)}`;
         return new Promise((resolve, reject) => {
             const req = http_1.default.get({
                 socketPath: this.sockPath,

package/dist/drivers/log-sources/metro-discovery.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMetroPort = isMetroPort;
+exports.discoverMetroPortForDevice = discoverMetroPortForDevice;
+exports.getDeviceDisplayName = getDeviceDisplayName;
+exports.selectTargetForDevice = selectTargetForDevice;
+exports.targetsForDevice = targetsForDevice;
+/**
+ * Deterministic Metro discovery helpers — shared between the daemon's
+ * log collector and CLI-side commands that need to query Metro for a
+ * specific device.
+ *
+ * The flow:
+ *   1. From a device ID (simulator UDID / emulator serial), find which Metro
+ *      port the device is connected to via `lsof` (iOS/tvOS) or
+ *      `adb reverse` (Android). No scanning / probing required.
+ *   2. From the same device ID, resolve the human-readable display name
+ *      (`xcrun simctl list` / `adb getprop`).
+ *   3. Query Metro's /json and filter targets whose `deviceName` matches.
+ *
+ * Matching by `deviceName` handles the case where multiple devices share a
+ * single Metro instance. It is deterministic unless the user has created
+ * two devices with the exact same display name.
+ */
+const child_process_1 = require("child_process");
+const metro_js_1 = require("./metro.js");
+/** Metro dev-server port ranges we consider. */
+const METRO_PORT_RANGES = [
+    [8080, 8099], // Metro default range
+    [19000, 19002], // Expo
+];
+function isMetroPort(port) {
+    return METRO_PORT_RANGES.some(([lo, hi]) => port >= lo && port <= hi);
+}
+function spawnCapture(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        proc.stdout?.on('data', (chunk) => {
+            out += chunk.toString();
+        });
+        proc.on('close', (code) => code === 0 ? resolve(out) : reject(new Error(`${cmd} failed (${code})`)));
+        proc.on('error', reject);
+    });
+}
+/**
+ * Deterministically locate the Metro port this specific device is connected
+ * to. Returns null if the device isn't connected to Metro.
+ */
+async function discoverMetroPortForDevice(platform, deviceId) {
+    if (platform === 'android') {
+        return discoverMetroPortAndroid(deviceId);
+    }
+    if (platform === 'ios' || platform === 'tvos') {
+        return discoverMetroPortIOS(deviceId);
+    }
+    return null;
+}
+async function discoverMetroPortAndroid(deviceId) {
+    try {
+        const output = await spawnCapture('adb', ['-s', deviceId, 'reverse', '--list']);
+        // Lines look like: host-13 tcp:8082 tcp:8082
+        for (const line of output.split('\n')) {
+            const match = line.match(/tcp:(\d+)\s+tcp:(\d+)/);
+            if (!match)
+                continue;
+            const hostPort = parseInt(match[2], 10);
+            if (isMetroPort(hostPort))
+                return hostPort;
+        }
+    }
+    catch {
+        // adb not available or device not connected
+    }
+    return null;
+}
+async function discoverMetroPortIOS(deviceId) {
+    const pids = await getSimAppPIDs(deviceId);
+    if (pids.length === 0)
+        return null;
+    const ports = new Set();
+    for (const pid of pids) {
+        try {
+            const output = await spawnCapture('lsof', [
+                '-a',
+                '-p',
+                String(pid),
+                '-iTCP',
+                '-sTCP:ESTABLISHED',
+                '-n',
+                '-P',
+            ]);
+            for (const line of output.split('\n')) {
+                // e.g. "Plex 18684 douwe 24u IPv6 ... TCP [::1]:55493->[::1]:8082 (ESTABLISHED)"
+                const match = line.match(/->(?:\[::1\]|127\.0\.0\.1):(\d+)\b/);
+                if (!match)
+                    continue;
+                const port = parseInt(match[1], 10);
+                if (isMetroPort(port))
+                    ports.add(port);
+            }
+        }
+        catch {
+            // lsof failed for this pid — try the next
+        }
+    }
+    if (ports.size === 0)
+        return null;
+    // Always verify each candidate is actually Metro (not some other service
+    // that happens to be in the Metro port range). A single candidate is
+    // still verified — otherwise a phantom port would be returned repeatedly.
+    for (const port of ports) {
+        try {
+            const targets = await (0, metro_js_1.fetchTargets)(port, 'localhost');
+            if (targets.length > 0)
+                return port;
+        }
+        catch {
+            // not Metro — skip
+        }
+    }
+    return null;
+}
+/**
+ * Enumerate PIDs of all foreground apps running inside an iOS/tvOS simulator.
+ * We don't filter by appId — the session's appId may be stale (the user might
+ * have launched the RN app outside conductor), and detecting Metro only needs
+ * to find *any* app with an established socket to a Metro port.
+ */
+async function getSimAppPIDs(deviceId) {
+    try {
+        const output = await spawnCapture('xcrun', ['simctl', 'spawn', deviceId, 'launchctl', 'list']);
+        const pids = [];
+        for (const line of output.split('\n')) {
+            // "18684\t0\tUIKitApplication:tv.plex.rn.app.dev[f218][rb-legacy]"
+            const match = line.match(/^(\d+)\s+\d+\s+UIKitApplication:/);
+            if (!match)
+                continue;
+            const pid = parseInt(match[1], 10);
+            if (pid <= 0)
+                continue;
+            pids.push(pid);
+        }
+        return pids;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Resolve a device's display name — the same string Metro reports as
+ * `deviceName` on /json targets.
+ *
+ * iOS/tvOS: the simulator's name from `xcrun simctl list devices`.
+ * Android: `ro.product.model` via adb.
+ */
+async function getDeviceDisplayName(platform, deviceId) {
+    if (platform === 'ios' || platform === 'tvos') {
+        try {
+            const output = await spawnCapture('xcrun', ['simctl', 'list', 'devices', '--json']);
+            const parsed = JSON.parse(output);
+            for (const sims of Object.values(parsed.devices)) {
+                const match = sims.find((s) => s.udid === deviceId);
+                if (match)
+                    return match.name;
+            }
+        }
+        catch {
+            // fall through
+        }
+        return null;
+    }
+    if (platform === 'android') {
+        try {
+            const output = await spawnCapture('adb', [
+                '-s',
+                deviceId,
+                'shell',
+                'getprop',
+                'ro.product.model',
+            ]);
+            const name = output.trim();
+            return name || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Filter Metro /json targets to those belonging to this device (by display
+ * name), preferring the fusebox runtime if present. Returns undefined when
+ * no matching target is found — the device may not be connected to Metro,
+ * or may share its display name with another device.
+ */
+function selectTargetForDevice(targets, displayName) {
+    const withWs = targets.filter((t) => t.webSocketDebuggerUrl);
+    const matches = withWs.filter((t) => t.deviceName === displayName);
+    if (matches.length === 0)
+        return undefined;
+    const fusebox = matches.find((t) => t.reactNative?.capabilities?.prefersFuseboxFrontend);
+    return fusebox ?? matches[0];
+}
+/** Convenience: all /json targets belonging to this device. */
+function targetsForDevice(targets, displayName) {
+    return targets.filter((t) => t.webSocketDebuggerUrl && t.deviceName === displayName);
+}