@houwert/conductor 0.19.1 → 0.20.0

package/dist/commands/capture-ui.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.captureUI = captureUI;
-exports.HELP = `  capture-ui [--output <path>]         Capture screenshot + hierarchy + a11y snapshot (for Argus UI panel)`;
+exports.HELP = `  capture-ui [--output <path.json>]    Capture screenshot + hierarchy + a11y snapshot as a JSON bundle (for Argus UI panel)`;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const runner_js_1 = require("../runner.js");
@@ -17,6 +17,19 @@ const a11y_js_1 = require("../drivers/a11y.js");
 const snapshot_store_js_1 = require("../snapshot-store.js");
 async function captureUI(outputPath, opts = {}, sessionName = 'default') {
     try {
+        // capture-ui always emits a JSON bundle (screenshot is embedded as base64).
+        // Reject non-JSON output paths up front so a `.png`/`.jpg` mistake doesn't
+        // silently produce an image-named file full of JSON. Use take-screenshot
+        // for an actual image.
+        if (outputPath) {
+            const ext = path_1.default.extname(outputPath).toLowerCase();
+            if (ext && ext !== '.json') {
+                (0, output_js_1.printError)(`capture-ui — \`--output\` must be a .json path (got "${ext}"). ` +
+                    `capture-ui writes a JSON bundle (screenshot + hierarchy + a11y snapshot), not an image. ` +
+                    `Use \`take-screenshot\` to save an image file.`, opts);
+                return 1;
+            }
+        }
         const driver = await (0, runner_js_1.getDriver)(sessionName);
         const capturedAt = new Date().toISOString();
         let platform;

package/dist/commands/debug.js

@@ -11,7 +11,7 @@ exports.debugInspectElement = debugInspectElement;
 exports.debugLogRegistry = debugLogRegistry;
 exports.debugReload = debugReload;
 exports.HELP = `  debug status [--port N]              Show RN debugger connection info
-  debug evaluate <expr> [--port N]     Run JS in the app runtime (Hermes/Fusebox)
+  debug evaluate <expr> [--port N]     Run JS in the app runtime (RN: Hermes/Fusebox; web: page context)
   debug component-tree [--port N]      Print the React component tree (on-screen)
   debug inspect-element <x,y>          Print the React component at a screen point
   debug log-registry [--source metro]  Summarize recent Metro/Hermes console logs`;
@@ -22,6 +22,18 @@ const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const metro_js_1 = require("../drivers/log-sources/metro.js");
 const metro_scripts_js_1 = require("../drivers/metro-scripts.js");
 const logs_js_1 = require("./logs.js");
+const runner_js_1 = require("../runner.js");
+const web_js_1 = require("../drivers/web.js");
+/** Resolve the web driver when this session targets a web device, else null (→ Metro path). */
+async function webDriverFor(sessionName) {
+    if (!sessionName || sessionName === 'default')
+        return null;
+    const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+    if (platform !== 'web')
+        return null;
+    const driver = await (0, runner_js_1.getDriver)(sessionName);
+    return driver instanceof web_js_1.WebDriver ? driver : null;
+}
 function newRequestId() {
     return crypto_1.default.randomBytes(6).toString('hex');
 }
@@ -88,6 +100,26 @@ async function debugEvaluate(expr, opts, sessionName, debugOpts) {
         (0, output_js_1.printError)('debug evaluate requires a JS expression', opts);
         return 1;
     }
+    // Web: evaluate in the page runtime via Playwright (no Metro/Hermes).
+    const web = await webDriverFor(sessionName);
+    if (web) {
+        try {
+            const { result, error } = await web.evaluate(expr);
+            if (error) {
+                (0, output_js_1.printError)(`debug evaluate — ${error}`, opts);
+                return 1;
+            }
+            if (opts.json)
+                (0, output_js_1.printData)({ result }, opts);
+            else
+                console.log(typeof result === 'string' ? result : JSON.stringify(result, null, 2));
+            return 0;
+        }
+        catch (err) {
+            (0, output_js_1.printError)(`debug evaluate — ${err instanceof Error ? err.message : String(err)}`, opts);
+            return 1;
+        }
+    }
     const port = debugOpts.port ?? 8081;
     const { deviceId, platformPromise } = resolveSession(sessionName);
     try {

package/dist/commands/logs.js

@@ -42,6 +42,21 @@ function formatEntry(entry, opts) {
     }
     return line;
 }
+/**
+ * Ensure both the device driver and its daemon are up before reading logs.
+ *
+ * getDriver() starts the daemon when the driver *port* is closed, but skips it
+ * when the port is already open — which happens after the daemon idle-times-out
+ * while leaving the driver alive (e.g. tvOS deliberately keeps its runner up
+ * across daemon restarts). The log collector lives inside the daemon, so a live
+ * driver port is not enough: we must guarantee the daemon socket itself is up,
+ * otherwise the log source connects to a dead socket. startDaemon() is
+ * idempotent — it returns immediately when the daemon already answers /status.
+ */
+async function ensureLogDaemon(sessionName) {
+    await (0, runner_js_1.getDriver)(sessionName);
+    await (0, client_js_1.startDaemon)(sessionName);
+}
 async function resolvePlatformAndDevice(sessionName) {
     try {
         const driver = await (0, runner_js_1.getDriver)(sessionName);
@@ -130,7 +145,7 @@ async function logs(opts = {}, sessionName = 'default', { source, level, list, r
     try {
         // ── Snapshot mode (--recent N) ──────────────────────────────────────────
         if (recent !== undefined) {
-            await (0, runner_js_1.getDriver)(sessionName);
+            await ensureLogDaemon(sessionName);
             const minSeverity = level ? (types_js_1.LEVEL_SEVERITY[level] ?? 0) : 0;
             const entries = await (0, client_js_1.fetchDaemonLogs)(sessionName, { limit: recent, level });
             for (const entry of entries) {
@@ -145,7 +160,7 @@ async function logs(opts = {}, sessionName = 'default', { source, level, list, r
         }
         // ── Streaming modes ─────────────────────────────────────────────────────
         // Ensure daemon is running; its log collector auto-discovers Metro.
-        await (0, runner_js_1.getDriver)(sessionName);
+        await ensureLogDaemon(sessionName);
         const minSeverity = level ? (types_js_1.LEVEL_SEVERITY[level] ?? 0) : 0;
         const logSource = new daemon_js_1.DaemonLogSource(sessionName);
         await logSource.connect();

package/dist/commands/network.js

@@ -3,12 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.networkLogs = networkLogs;
 exports.networkRequest = networkRequest;
-exports.HELP = `  network logs [--port N] [--limit N]  Read recent HTTP traffic (installs a fetch/XHR shim once)
+exports.HELP = `  network logs [--port N] [--limit N]  Read recent HTTP traffic (RN: fetch/XHR shim; web: all traffic via Playwright)
   network request <url> [--method M] [--body STR] [--header K=V] [--port N]
                                        Issue an HTTP request from the app's context`;
 const output_js_1 = require("../output.js");
 const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const runner_js_1 = require("../runner.js");
+const web_js_1 = require("../drivers/web.js");
+/** Resolve the web driver when this session targets a web device, else null (→ Metro path). */
+async function webDriverFor(sessionName) {
+    if (!sessionName || sessionName === 'default')
+        return null;
+    const platform = await (0, bootstrap_js_1.detectPlatform)(sessionName).catch(() => undefined);
+    if (platform !== 'web')
+        return null;
+    const driver = await (0, runner_js_1.getDriver)(sessionName);
+    return driver instanceof web_js_1.WebDriver ? driver : null;
+}
+function formatNetEntry(e) {
+    const ts = e.timestamp.slice(11, 23);
+    const status = e.error ? `ERR ${e.error}` : e.status !== null ? String(e.status) : '...';
+    const dur = e.durationMs !== null ? `${e.durationMs}ms` : '-';
+    return `${ts}  ${status.padEnd(6)} ${e.method.padEnd(6)} ${e.url} (${dur}, ${e.resourceType ?? e.kind ?? ''})`;
+}
 const INSTALL_SHIM_SCRIPT = `
 (() => {
   if (globalThis.__CONDUCTOR_NET__ && globalThis.__CONDUCTOR_NET__.installed) {
@@ -99,8 +117,30 @@ function resolveSession(sessionName) {
     };
 }
 async function networkLogs(opts, sessionName, netOpts) {
-    const port = netOpts.port ?? 8081;
     const limit = netOpts.limit ?? 50;
+    // Web: Playwright captures all traffic natively — no Metro, no injected shim.
+    const web = await webDriverFor(sessionName);
+    if (web) {
+        try {
+            const { entries } = await web.networkLogs({ limit });
+            if (opts.json) {
+                (0, output_js_1.printData)({ installed: true, count: entries.length, entries }, opts);
+            }
+            else if (entries.length === 0) {
+                console.log('No network entries captured yet. Reload the app and try again.');
+            }
+            else {
+                for (const e of entries)
+                    console.log(formatNetEntry(e));
+            }
+            return 0;
+        }
+        catch (err) {
+            (0, output_js_1.printError)(`network logs — ${err instanceof Error ? err.message : String(err)}`, opts);
+            return 1;
+        }
+    }
+    const port = netOpts.port ?? 8081;
     const { deviceId, platformPromise } = resolveSession(sessionName);
     try {
         const platform = await platformPromise;
@@ -144,6 +184,31 @@ async function networkRequest(url, opts, sessionName, reqOpts) {
             headers[h.slice(0, idx)] = h.slice(idx + 1);
     }
     const body = reqOpts.body;
+    // Web: issue via the browser context (shares the page's cookies/session).
+    const web = await webDriverFor(sessionName);
+    if (web) {
+        try {
+            const result = await web.networkRequest(url, { method, headers, body });
+            if (opts.json)
+                (0, output_js_1.printData)(result, opts);
+            else {
+                if (result.error)
+                    console.error(`error: ${result.error}`);
+                console.log(`status: ${result.status ?? 'n/a'}`);
+                for (const [k, v] of Object.entries(result.headers ?? {}))
+                    console.log(`${k}: ${v}`);
+                if (result.body !== undefined) {
+                    console.log('');
+                    console.log(result.body);
+                }
+            }
+            return result.ok ? 0 : 1;
+        }
+        catch (err) {
+            (0, output_js_1.printError)(`network request — ${err instanceof Error ? err.message : String(err)}`, opts);
+            return 1;
+        }
+    }
     const init = JSON.stringify({
         method,
         headers,

package/dist/commands/press-key.js

@@ -149,6 +149,13 @@ async function pressKey(key, opts = {}, sessionName = 'default') {
                 Escape: 'Escape',
                 Home: 'Home',
                 End: 'End',
+                // Canvas webtv apps (Lightning/WPE) navigate focus via the D-pad, which they listen
+                // for as arrow keys (and Enter for select). Maps the TV remote onto web keyboard.
+                'Remote Dpad Up': 'ArrowUp',
+                'Remote Dpad Down': 'ArrowDown',
+                'Remote Dpad Left': 'ArrowLeft',
+                'Remote Dpad Right': 'ArrowRight',
+                'Remote Dpad Center': 'Enter',
             };
             const webKey = WEB_KEY_MAP[matched];
             if (webKey) {

package/dist/daemon/web-server.js

@@ -71,6 +71,52 @@ function attachConsoleListeners(page) {
             source: 'console',
         });
     });
+    attachNetworkListeners(page);
+}
+const MAX_NETWORK_BUFFER = 500;
+const _networkBuffer = [];
+let _netSeq = 0;
+function pushNetworkEntry(entry) {
+    _networkBuffer.push(entry);
+    if (_networkBuffer.length > MAX_NETWORK_BUFFER) {
+        _networkBuffer.splice(0, _networkBuffer.length - MAX_NETWORK_BUFFER);
+    }
+}
+/**
+ * Capture all page network traffic via Playwright events — covers fetch/XHR plus
+ * document/script/image/media loads (a canvas webtv app's API calls included), without
+ * injecting a shim into the page (unlike the React Native Metro path).
+ */
+function attachNetworkListeners(page) {
+    const inflight = new WeakMap();
+    page.on('request', (req) => {
+        const entry = {
+            id: _netSeq++,
+            timestamp: new Date().toISOString(),
+            method: req.method(),
+            url: req.url(),
+            resourceType: req.resourceType(),
+            status: null,
+            durationMs: null,
+            error: null,
+        };
+        inflight.set(req, { entry, start: Date.now() });
+        pushNetworkEntry(entry);
+    });
+    page.on('response', (res) => {
+        const rec = inflight.get(res.request());
+        if (rec) {
+            rec.entry.status = res.status();
+            rec.entry.durationMs = Date.now() - rec.start;
+        }
+    });
+    page.on('requestfailed', (req) => {
+        const rec = inflight.get(req);
+        if (rec) {
+            rec.entry.error = req.failure()?.errorText ?? 'request failed';
+            rec.entry.durationMs = Date.now() - rec.start;
+        }
+    });
 }
 // ── ARIA snapshot parser ─────────────────────────────────────────────────────
 /**
@@ -423,6 +469,113 @@ async function stampFocusFromDocumentActiveElement(page, elements) {
         rectPick.best.focused = true;
     }
 }
+/** IoU + center-inside score of a candidate node's bounds against a mirror rect. */
+function overlapScore(bounds, m) {
+    const x1 = Math.max(m.x, bounds.x);
+    const y1 = Math.max(m.y, bounds.y);
+    const x2 = Math.min(m.x + m.width, bounds.x + bounds.width);
+    const y2 = Math.min(m.y + m.height, bounds.y + bounds.height);
+    const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    if (inter <= 0)
+        return 0;
+    const union = m.width * m.height + bounds.width * bounds.height - inter;
+    const iou = union > 0 ? inter / union : 0;
+    const mcx = m.x + m.width / 2;
+    const mcy = m.y + m.height / 2;
+    const centerInside = mcx >= bounds.x &&
+        mcx <= bounds.x + bounds.width &&
+        mcy >= bounds.y &&
+        mcy <= bounds.y + bounds.height;
+    return centerInside ? iou + 1 : iou;
+}
+/** Find the existing tree node whose bounds best overlap a mirror rect (>0.5 score). */
+function bestOverlappingNode(elements, m) {
+    let best = null;
+    let bestScore = 0.5;
+    const walk = (els) => {
+        for (const el of els) {
+            if (el.bounds) {
+                const s = overlapScore(el.bounds, m);
+                if (s > bestScore) {
+                    bestScore = s;
+                    best = el;
+                }
+            }
+            if (el.children)
+                walk(el.children);
+        }
+    };
+    walk(elements);
+    return best;
+}
+/**
+ * Harvest a canvas DOM-inspector mirror into the hierarchy. Canvas webtv frameworks
+ * (Lightning/WPE/RDK) render the whole UI into one `<canvas>` and expose the scene graph as
+ * off-screen `<div>`s carrying `data-testid` (real identity) and `data-focused="true"` (focus
+ * — the canvas owns `document.activeElement`, so the normal focus path can't see it).
+ *
+ * Each mirror node is matched to an existing ARIA node by bounds overlap and used to enrich it
+ * (testId + focus); unmatched mirror nodes are appended as new nodes. Mirror rects come from
+ * `getBoundingClientRect`, i.e. the same viewport-CSS-pixel space taps use — drive TV apps at
+ * the app's native resolution (e.g. `set-viewport 1920 1080`) so lower nodes aren't off-screen.
+ */
+async function harvestDomMirror(page, elements) {
+    let mirror = null;
+    try {
+        mirror = (await page.evaluate(`(() => {
+      const nodes = document.querySelectorAll('[data-testid],[data-focused]');
+      if (!nodes.length) return null;
+      const out = [];
+      nodes.forEach((el) => {
+        const r = el.getBoundingClientRect();
+        out.push({
+          testId: el.getAttribute('data-testid') || '',
+          focused: el.getAttribute('data-focused') === 'true',
+          role: el.getAttribute('role') || 'generic',
+          name: (el.getAttribute('aria-label') || el.textContent || '').trim().slice(0, 200),
+          disabled: el.getAttribute('aria-disabled') === 'true',
+          x: r.x, y: r.y, width: r.width, height: r.height,
+        });
+      });
+      return out;
+    })()`));
+    }
+    catch {
+        return;
+    }
+    if (!mirror || mirror.length === 0)
+        return;
+    // data-focused is authoritative for canvas apps (activeElement is the <canvas>, never the
+    // focused scene node), so clear any focus already inferred from the ARIA snapshot.
+    if (mirror.some((m) => m.focused))
+        clearFocusedFlags(elements);
+    for (const m of mirror) {
+        const bounds = m.width > 0 && m.height > 0
+            ? { x: m.x, y: m.y, width: m.width, height: m.height }
+            : undefined;
+        const target = bounds ? bestOverlappingNode(elements, m) : null;
+        if (target) {
+            if (m.testId)
+                target.testId = m.testId;
+            if (m.focused)
+                target.focused = true;
+            if (!target.name && m.name)
+                target.name = m.name;
+        }
+        else {
+            elements.push({
+                role: m.role,
+                name: m.name,
+                ref: '',
+                testId: m.testId || undefined,
+                bounds,
+                enabled: !m.disabled,
+                focused: m.focused,
+                children: [],
+            });
+        }
+    }
+}
 // ── Web server ───────────────────────────────────────────────────────────────
 const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
 let _browser = null;
@@ -832,6 +985,9 @@ async function handleRequest(req, res, dlog) {
                 await resolveBoundingBoxesByRole(p, elements);
                 clearFocusedFlags(elements);
                 applyFocusFromAriaSnapshotYaml(ariaSnapshot, elements);
+                // Canvas webtv: merge the data-testid/data-focused mirror before falling back to
+                // document.activeElement (which is the <canvas>, not the focused scene node).
+                await harvestDomMirror(p, elements);
                 await stampFocusFromDocumentActiveElement(p, elements);
                 jsonResponse(res, {
                     url: p.url(),
@@ -937,6 +1093,17 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { entries });
                 return;
             }
+            case '/networkLogs': {
+                const since = parsedUrl.query['since'] ?? '';
+                const limit = Number(parsedUrl.query['limit'] ?? 0);
+                let entries = since
+                    ? _networkBuffer.filter((e) => e.timestamp > since)
+                    : _networkBuffer.slice();
+                if (limit > 0)
+                    entries = entries.slice(-limit);
+                jsonResponse(res, { entries });
+                return;
+            }
             default: {
                 res.writeHead(404);
                 res.end('Not found');
@@ -1005,6 +1172,58 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { ok: true });
                 return;
             }
+            case '/evaluate': {
+                const expr = body['expr'];
+                if (!expr) {
+                    jsonResponse(res, { error: 'expr is required' }, 400);
+                    return;
+                }
+                const p = await getPage(dlog);
+                try {
+                    // Wrap so a bare expression (e.g. `1+1`) and a statement block both work.
+                    const result = await p.evaluate(`(() => { return (${expr}); })()`).catch(
+                    // Fall back to evaluating as-is for IIFEs / `async () => …` expressions.
+                    () => p.evaluate(expr));
+                    jsonResponse(res, { result });
+                }
+                catch (e) {
+                    jsonResponse(res, { error: e instanceof Error ? e.message : String(e) });
+                }
+                return;
+            }
+            case '/networkRequest': {
+                const url = body['url'];
+                if (!url) {
+                    jsonResponse(res, { error: 'url is required' }, 400);
+                    return;
+                }
+                const reqMethod = (body['method'] ?? 'GET').toUpperCase();
+                const headers = body['headers'] ?? {};
+                const data = body['body'];
+                if (!_context) {
+                    jsonResponse(res, { error: 'no browser context' }, 500);
+                    return;
+                }
+                try {
+                    const apiRes = await _context.request.fetch(url, {
+                        method: reqMethod,
+                        headers,
+                        ...(data !== undefined ? { data } : {}),
+                    });
+                    const hdrs = apiRes.headers();
+                    const text = await apiRes.text();
+                    jsonResponse(res, {
+                        ok: apiRes.ok(),
+                        status: apiRes.status(),
+                        headers: hdrs,
+                        body: text,
+                    });
+                }
+                catch (e) {
+                    jsonResponse(res, { ok: false, error: e instanceof Error ? e.message : String(e) });
+                }
+                return;
+            }
             case '/navigate':
             case '/launchApp': {
                 const targetUrl = (body['url'] ?? body['bundleId'] ?? body['appId']);

package/dist/drivers/element-resolver.js

@@ -439,7 +439,7 @@ function collectWebElements(nodes, results) {
     for (const node of nodes) {
         const visible = node.bounds && node.bounds.width > 0 && node.bounds.height > 0;
         if (visible) {
-            const hasContent = !!(node.name || node.ref);
+            const hasContent = !!(node.name || node.ref || node.testId);
             const isLeaf = !node.children || node.children.length === 0;
             if (hasContent || isLeaf) {
                 results.push(node);
@@ -450,10 +450,14 @@ function collectWebElements(nodes, results) {
         }
     }
 }
+/** Web id field: prefer the canvas mirror's `data-testid`, else the ARIA `ref`. */
+function webElementId(node) {
+    return node.testId || node.ref;
+}
 function matchesWebElement(node, sel) {
     if (sel.query) {
         const textOk = matchPatternAgainstAnyTextField(sel.query, [node.name]);
-        const idOk = matchPatternAgainstElementId(sel.query, node.ref);
+        const idOk = matchPatternAgainstElementId(sel.query, webElementId(node));
         if (!textOk && !idOk)
             return false;
     }
@@ -462,7 +466,7 @@ function matchesWebElement(node, sel) {
             return false;
     }
     if (sel.id) {
-        if (!matchPatternAgainstElementId(sel.id, node.ref))
+        if (!matchPatternAgainstElementId(sel.id, webElementId(node)))
             return false;
     }
     if (sel.enabled !== undefined && node.enabled !== sel.enabled)
@@ -532,7 +536,7 @@ function findWebElement(hierarchy, sel) {
     matches.forEach((n, i) => {
         const b = n.bounds;
         const interactive = WEB_INTERACTIVE_ROLES.has(n.role);
-        (0, verbose_js_1.log)(`  [${i}] text="${n.name}" ref="${n.ref}" role="${n.role}" ` +
+        (0, verbose_js_1.log)(`  [${i}] text="${n.name}" id="${webElementId(n)}" role="${n.role}" ` +
             `bounds=[${Math.round(b.x)},${Math.round(b.y)}][${Math.round(b.x + b.width)},${Math.round(b.y + b.height)}]` +
             `${interactive ? ' (interactive)' : ''}`);
     });
@@ -554,7 +558,7 @@ function findWebElement(hierarchy, sel) {
         return null;
     }
     const b = node.bounds;
-    (0, verbose_js_1.log)(`[Web] chose [${idx}] text="${node.name}" ref="${node.ref}" role="${node.role}" ` +
+    (0, verbose_js_1.log)(`[Web] chose [${idx}] text="${node.name}" id="${webElementId(node)}" role="${node.role}" ` +
         `bounds=[${Math.round(b.x)},${Math.round(b.y)}][${Math.round(b.x + b.width)},${Math.round(b.y + b.height)}] ` +
         `→ tap (${Math.round(b.x + b.width / 2)}, ${Math.round(b.y + b.height / 2)})`);
     return {
@@ -562,7 +566,7 @@ function findWebElement(hierarchy, sel) {
         centerY: b.y + b.height / 2,
         bounds: { x: b.x, y: b.y, width: b.width, height: b.height },
         text: node.name || undefined,
-        id: node.ref || undefined,
+        id: webElementId(node) || undefined,
     };
 }
 /**
@@ -579,6 +583,8 @@ function visitWeb(nodes, lines, depth) {
         parts.push(node.role);
         if (node.name)
             parts.push(`"${node.name}"`);
+        if (node.testId)
+            parts.push(`id=${node.testId}`);
         if (node.ref)
             parts.push(`ref=${node.ref}`);
         if (node.bounds) {
@@ -588,7 +594,10 @@ function visitWeb(nodes, lines, depth) {
         if (!node.enabled)
             parts.push('disabled');
         // Only output nodes that have content
-        if (node.name || node.ref || (node.bounds && (!node.children || node.children.length === 0))) {
+        if (node.name ||
+            node.ref ||
+            node.testId ||
+            (node.bounds && (!node.children || node.children.length === 0))) {
             lines.push(`${'  '.repeat(depth)}${parts.join(' ')}`);
         }
         if (node.children) {

package/dist/drivers/web.js

@@ -60,6 +60,14 @@ class WebDriver {
         }
         return JSON.parse(data.toString('utf-8'));
     }
+    /** POST that returns the parsed JSON response body (unlike `post`, which discards it). */
+    async postJson(path, body) {
+        const { status, data } = await this.request('POST', `/${path}`, body);
+        if (status < 200 || status >= 300) {
+            throw new Error(`Web driver ${path} failed (HTTP ${status}): ${data.toString('utf-8').slice(0, 200)}`);
+        }
+        return JSON.parse(data.toString('utf-8'));
+    }
     async isAlive() {
         try {
             const { status } = await this.request('GET', '/status');
@@ -154,6 +162,24 @@ class WebDriver {
         }
         return data.toString('utf-8');
     }
+    /** Recent page network traffic captured via Playwright request/response events. */
+    async networkLogs(opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.limit)
+            qs.set('limit', String(opts.limit));
+        if (opts.since)
+            qs.set('since', opts.since);
+        const s = qs.toString();
+        return this.get(`networkLogs${s ? `?${s}` : ''}`);
+    }
+    /** Issue an HTTP request from the browser context (shares cookies/session with the page). */
+    async networkRequest(url, opts = {}) {
+        return this.postJson('networkRequest', { url, ...opts });
+    }
+    /** Evaluate a JS expression in the page runtime and return its (JSON-serializable) value. */
+    async evaluate(expr) {
+        return this.postJson('evaluate', { expr });
+    }
     async eraseAllText(count = 50) {
         await this.post('eraseText', { count });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {