@houwert/conductor 0.29.3 → 0.30.0

package/dist/commands/stop-device.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HELP = void 0;
 exports.stopDevice = stopDevice;
 exports.HELP = `  stop-device [<name-or-id>]
-    --platform <ios|tvos|android|web|vega> Scope to a single platform
+    --platform <ios|tvos|android|web|vega|roku> Scope to a single platform
     --all                             Stop all booted simulators / running emulators / web sessions`;
 const runner_js_1 = require("../runner.js");
 const sdk_js_1 = require("../android/sdk.js");
@@ -36,6 +36,7 @@ async function stopDevice(nameOrId, opts, flags) {
     const includeAndroid = !platform || platform === 'android';
     const includeWeb = !platform || platform === 'web';
     const includeVega = !platform || platform === 'vega';
+    const includeRoku = !platform || platform === 'roku';
     const stopped = [];
     // ── --all mode ───────────────────────────────────────────────────────────
     if (flags.all) {
@@ -51,6 +52,8 @@ async function stopDevice(nameOrId, opts, flags) {
                 continue;
             if (d.platform === 'vega' && !includeVega)
                 continue;
+            if (d.platform === 'roku' && !includeRoku)
+                continue;
             try {
                 if (d.platform === 'ios' || d.platform === 'tvos') {
                     await shutdownSimulator(d.id);
@@ -62,6 +65,10 @@ async function stopDevice(nameOrId, opts, flags) {
                     // Vega VVD lifecycle is owned by Amazon's tooling — we only stop our log daemon.
                     await (0, client_js_1.stopDaemon)(d.id);
                 }
+                else if (d.platform === 'roku') {
+                    // A Roku is physical hardware we never booted; there is nothing to stop.
+                    continue;
+                }
                 stopped.push({ id: d.id, name: d.name, platform: d.platform });
             }
             catch (e) {
@@ -104,6 +111,10 @@ async function stopDevice(nameOrId, opts, flags) {
             // Vega VVD lifecycle is owned by Amazon's tooling — we only stop our log daemon.
             await (0, client_js_1.stopDaemon)(match.id);
         }
+        else if (match.platform === 'roku') {
+            (0, output_js_1.printError)(`${match.name} is a physical Roku device — conductor never booted it, so there is nothing to stop.`, opts);
+            return 1;
+        }
     }
     catch (e) {
         (0, output_js_1.printError)(e instanceof Error ? e.message : String(e), opts);

package/dist/commands/swipe.js

@@ -13,6 +13,7 @@ const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const vega_js_1 = require("../drivers/vega.js");
+const roku_js_1 = require("../drivers/roku.js");
 const utils_js_1 = require("../utils.js");
 function parseCoordPair(s) {
     const [xs, ys] = s.split(',').map((p) => p.trim());
@@ -71,7 +72,9 @@ async function swipe(direction, opts = {}, sessionName = 'default', flags = {})
             }
             await driver.swipe(startX, startY, endX, endY, durationMs);
         }
-        else if (driver instanceof android_js_1.AndroidDriver || driver instanceof vega_js_1.VegaDriver) {
+        else if (driver instanceof android_js_1.AndroidDriver ||
+            driver instanceof vega_js_1.VegaDriver ||
+            driver instanceof roku_js_1.RokuDriver) {
             const { widthPixels: w, heightPixels: h } = await driver.deviceInfo();
             const durationMs = flags.duration ?? 500;
             if (flags.start && flags.end) {

package/dist/commands/tap.js

@@ -28,6 +28,7 @@ const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const vega_js_1 = require("../drivers/vega.js");
+const roku_js_1 = require("../drivers/roku.js");
 const wait_js_1 = require("../drivers/wait.js");
 const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const snapshot_store_js_1 = require("../snapshot-store.js");
@@ -88,8 +89,8 @@ async function tap(query, opts = {}, sessionName = 'default', flags = {}) {
         else if (driver instanceof web_js_1.WebDriver) {
             el = await (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel);
         }
-        else if (driver instanceof vega_js_1.VegaDriver) {
-            // Vega emits uiautomator-style XML, so it reuses the Android resolver.
+        else if (driver instanceof vega_js_1.VegaDriver || driver instanceof roku_js_1.RokuDriver) {
+            // Vega and Roku emit uiautomator-style XML, so they reuse the Android resolver.
             el = await (0, wait_js_1.waitForAndroidElement)(() => driver.viewHierarchy(), sel);
         }
         else if (driver instanceof android_js_1.AndroidDriver) {

package/dist/commands/uninstall-app.js

@@ -9,6 +9,7 @@ const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const vega_js_1 = require("../drivers/vega.js");
+const roku_js_1 = require("../drivers/roku.js");
 async function uninstallApp(appId, opts = {}, sessionName = 'default') {
     if (!appId) {
         (0, output_js_1.printError)('uninstall-app requires <appId>', opts);
@@ -24,6 +25,9 @@ async function uninstallApp(appId, opts = {}, sessionName = 'default') {
         else if (driver instanceof vega_js_1.VegaDriver) {
             throw new Error('uninstall-app is not supported on vega (Amazon Fire TV)');
         }
+        else if (driver instanceof roku_js_1.RokuDriver) {
+            throw new Error('uninstall-app is not supported on roku');
+        }
         else if (driver instanceof android_js_1.AndroidDriver) {
             await driver.uninstallApp(appId);
         }

package/dist/daemon/server.js

@@ -177,8 +177,9 @@ let _driverStartError = null;
 async function ensureDriverRunning() {
     if (_restartInProgress || !_driverStarted)
         return;
-    // Vega has no driver process/port to health-check — control is host-side via the CLI.
-    if (driverPlatform === 'vega')
+    // Vega and Roku have no driver process/port to health-check — control is
+    // host-side (the vega CLI) or over the network (Roku ECP).
+    if (driverPlatform === 'vega' || driverPlatform === 'roku')
         return;
     let alive;
     if (driverPlatform === 'android') {
@@ -317,6 +318,9 @@ async function main() {
             else if (driverPlatform === 'vega') {
                 dlog('vega: no driver process to stop (control is host-side via the CLI)');
             }
+            else if (driverPlatform === 'roku') {
+                dlog('roku: no driver process to stop (control is ECP over the network)');
+            }
             else if (driverPlatform === 'web') {
                 dlog('Stopping web driver');
                 try {
@@ -449,6 +453,12 @@ async function main() {
                     _driverStarted = true;
                     dlog('vega: no driver process to start; collecting logs only');
                 }
+                else if (platform === 'roku') {
+                    // Roku has neither a driver process nor a log stream to collect, so
+                    // the daemon has nothing to do — commands drive the device directly.
+                    _driverStarted = true;
+                    dlog('roku: no driver process and no device logs; daemon is idle');
+                }
                 else {
                     await startDriverForPlatform(platform);
                 }
@@ -487,8 +497,8 @@ async function main() {
     });
 }
 /**
- * Bring up the driver process for a non-vega platform. Sets `_driverStarted` /
- * `_driverStartError`. Extracted so the vega path can skip it entirely.
+ * Bring up the driver process for a platform that has one. Sets `_driverStarted` /
+ * `_driverStartError`. Extracted so the vega and roku paths can skip it entirely.
  */
 async function startDriverForPlatform(platform) {
     let driverAlive;

package/dist/drivers/bootstrap.js

@@ -63,6 +63,11 @@ async function detectPlatform(deviceId) {
         _platformCache.set(deviceId, 'vega');
         return 'vega';
     }
+    // Roku: "roku:<host>" (e.g. "roku:192.168.1.100")
+    if (deviceId === 'roku' || deviceId.startsWith('roku:')) {
+        _platformCache.set(deviceId, 'roku');
+        return 'roku';
+    }
     // Check if it looks like an iOS/tvOS simulator UUID (8-4-4-4-12 hex chars)
     const iosUuidRe = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
     if (iosUuidRe.test(deviceId)) {
@@ -174,6 +179,11 @@ async function getDriverPort(platform, deviceId) {
         else if (platform === 'vega') {
             port = state.nextVegaPort++;
         }
+        else if (platform === 'roku') {
+            // Roku is driven entirely over the network (ECP on the device's own port
+            // 8060) — there is no host-side driver process, so no port to reserve.
+            return 0;
+        }
         else {
             port = state.nextAndroidPort++;
         }

package/dist/drivers/flow-runner.js

@@ -21,6 +21,8 @@ const ios_js_1 = require("./ios.js");
 const android_js_1 = require("./android.js");
 const web_js_1 = require("./web.js");
 const vega_js_1 = require("./vega.js");
+const roku_js_1 = require("./roku.js");
+const key_mapping_js_1 = require("./roku/key-mapping.js");
 const wait_js_1 = require("./wait.js");
 const direct_ios_selector_js_1 = require("./direct-ios-selector.js");
 const perf_hooks_1 = require("perf_hooks");
@@ -552,7 +554,9 @@ function getConductorObj(driver, output) {
             ? 'web'
             : driver instanceof vega_js_1.VegaDriver
                 ? 'vega'
-                : 'android';
+                : driver instanceof roku_js_1.RokuDriver
+                    ? 'roku'
+                    : 'android';
     return {
         platform,
         copiedText: output['__copiedText'] ?? '',
@@ -684,7 +688,7 @@ async function executeCommandBody(key, val, driver, opts) {
                     await driver.pressKey('delete');
             }
             else {
-                // Android, web, and vega all expose eraseAllText.
+                // Android, web, vega, and roku all expose eraseAllText.
                 await driver.eraseAllText(n);
             }
             break;
@@ -825,7 +829,7 @@ async function executeCommandBody(key, val, driver, opts) {
                 await driver.back();
             else if (driver instanceof web_js_1.WebDriver)
                 await driver.goBack();
-            else if (driver instanceof vega_js_1.VegaDriver)
+            else if (driver instanceof vega_js_1.VegaDriver || driver instanceof roku_js_1.RokuDriver)
                 await driver.back();
             // iOS has no hardware back button — noop
             break;
@@ -1113,6 +1117,11 @@ async function executeCommandBody(key, val, driver, opts) {
                     throw new Error(`pressKey: key "${val}" is not supported on vega`);
                 await driver.pressButton(button);
             }
+            else if (driver instanceof roku_js_1.RokuDriver) {
+                if (!(0, key_mapping_js_1.rokuEcpKey)(keyName))
+                    throw new Error(`pressKey: key "${val}" is not supported on roku`);
+                await driver.pressKeyNamed(keyName);
+            }
             else {
                 const keycode = ANDROID_KEYCODES[keyName];
                 if (keycode === undefined)
@@ -1133,6 +1142,10 @@ async function executeCommandBody(key, val, driver, opts) {
             else if (driver instanceof vega_js_1.VegaDriver) {
                 // No reliable keyboard-hide primitive on vega — noop
             }
+            else if (driver instanceof roku_js_1.RokuDriver) {
+                // Roku dismisses its on-screen keyboard with Back.
+                await driver.back();
+            }
             else {
                 await driver.pressKeyEvent(111); // KEYCODE_ESCAPE
             }

package/dist/drivers/roku/app-ui-parser.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRokuAppUI = parseRokuAppUI;
+/**
+ * Converts Roku's ECP `/query/app-ui` SceneGraph XML into the uiautomator-style
+ * `<node>` XML that conductor's Android element resolver (`parseAndroidHierarchy`,
+ * `findAndroidElement`, `inspectAndroidToText`) already understands — the same
+ * trick Vega uses, so Roku reuses the entire inspection and element-resolution path.
+ *
+ * app-ui shape:
+ * ```
+ * <app-ui>
+ *   <status>OK</status>
+ *   <topscreen>
+ *     <plugin id="dev" name="MyApp"/>
+ *     <screen focused="true" type="screen">
+ *       <RenderableNode name="myId" subtype="Group" bounds="{0, 0, 1920, 1080}" …>
+ * ```
+ * Node `name` attributes (SceneGraph node ids) become `resource-id`, `subtype`
+ * becomes `class`, and `bounds` are accumulated with parent `translation` offsets
+ * into scene-absolute `[x1,y1][x2,y2]` rects — the Android adapter's format.
+ */
+const xml_js_1 = require("../xml.js");
+const EMPTY = '<?xml version="1.0" encoding="UTF-8"?>\n<hierarchy />';
+/** Parse Roku app-ui XML and re-emit it as uiautomator `<node>` XML. */
+function parseRokuAppUI(xml, screenWidth = 1920, screenHeight = 1080) {
+    const root = (0, xml_js_1.parseXml)(xml);
+    if (!root)
+        return EMPTY;
+    const topscreen = (0, xml_js_1.childElement)(root, 'topscreen');
+    const screen = topscreen && (0, xml_js_1.childElement)(topscreen, 'screen');
+    if (!screen)
+        return EMPTY;
+    const lines = ['<?xml version="1.0" encoding="UTF-8"?>', '<hierarchy>'];
+    // A root node spanning the screen: it gives the screenshot cropper its reference
+    // bounds, matching the window node Android and Vega both emit.
+    // Never focused: `<screen focused>` means the screen holds device focus, not that
+    // it is the focused element, and claiming it here would shadow the real one.
+    const rootAttrs = [
+        'class="Screen"',
+        `bounds="[0,0][${screenWidth},${screenHeight}]"`,
+        'clickable="false"',
+        'focusable="false"',
+        'focused="false"',
+        'enabled="true"',
+    ];
+    lines.push(`  <node ${rootAttrs.join(' ')}>`);
+    emitChildren(screen, { x: 0, y: 0 }, false, lines, 2);
+    lines.push('  </node>');
+    lines.push('</hierarchy>');
+    return lines.join('\n');
+}
+function emitChildren(parent, offset, parentIsRowListItem, lines, depth) {
+    // A RowListItem's trailing Group duplicates the item it wraps.
+    const children = parentIsRowListItem && parent.children.length > 1
+        ? parent.children.slice(0, -1)
+        : parent.children;
+    for (const child of children)
+        emitNode(child, offset, parentIsRowListItem, lines, depth);
+}
+function emitNode(node, parentOffset, parentIsRowListItem, lines, depth) {
+    // SceneGraph doesn't render an invisible node or anything beneath it, but ECP
+    // still reports the subtree with real bounds. Keeping them would let
+    // assert-visible match a hidden element and assert-not-visible fail on one.
+    if (node.attrs['visible'] === 'false')
+        return;
+    const opacity = parseFloat(node.attrs['opacity'] ?? '100');
+    if (!isNaN(opacity) && opacity <= 0)
+        return;
+    // ECP reports the SceneGraph type in `subtype`; the element name is only a
+    // fallback, and for a generic `RenderableNode` it says nothing at all.
+    const subtype = node.attrs['subtype'] || (node.tag === 'RenderableNode' ? 'Group' : node.tag);
+    const translation = parseNumericArray(node.attrs['translation'], 2);
+    const bounds = parseNumericArray(node.attrs['bounds'], 4);
+    // Offset this node's children inherit.
+    let nodeOffset = parentOffset;
+    if (subtype === 'MarkupGrid' && parentIsRowListItem) {
+        if (bounds)
+            nodeOffset = { x: bounds[0] + parentOffset.x, y: bounds[1] + parentOffset.y };
+    }
+    else if (translation) {
+        nodeOffset = { x: translation[0] + parentOffset.x, y: translation[1] + parentOffset.y };
+    }
+    const focusable = node.attrs['focusable'] === 'true';
+    const focused = node.attrs['focused'] === 'true';
+    const attrs = [`class="${(0, xml_js_1.xmlEscape)(subtype)}"`];
+    if (node.attrs['name'])
+        attrs.push(`resource-id="${(0, xml_js_1.xmlEscape)(node.attrs['name'])}"`);
+    if (node.attrs['text'])
+        attrs.push(`text="${(0, xml_js_1.xmlEscape)(node.attrs['text'])}"`);
+    if (bounds) {
+        const x1 = Math.round(bounds[0] + parentOffset.x);
+        const y1 = Math.round(bounds[1] + parentOffset.y);
+        attrs.push(`bounds="[${x1},${y1}][${x1 + Math.round(bounds[2])},${y1 + Math.round(bounds[3])}]"`);
+    }
+    attrs.push(`clickable="${focusable}"`, `focusable="${focusable}"`);
+    attrs.push(`focused="${focused}"`, `selected="${focused}"`, 'enabled="true"');
+    const indent = '  '.repeat(depth);
+    if (node.children.length === 0) {
+        lines.push(`${indent}<node ${attrs.join(' ')} />`);
+        return;
+    }
+    lines.push(`${indent}<node ${attrs.join(' ')}>`);
+    emitChildren(node, nodeOffset, node.tag === 'RowListItem', lines, depth + 1);
+    lines.push(`${indent}</node>`);
+}
+/**
+ * Parses a Roku numeric array attribute (`{0, 0, 1920, 1080}`), or null if it
+ * doesn't hold at least `minSize` values — callers index it positionally, so a
+ * short array is no more usable than a missing one.
+ */
+function parseNumericArray(value, minSize) {
+    if (!value)
+        return null;
+    const cleaned = value.replace(/[{}]/g, '').trim();
+    if (!cleaned)
+        return null;
+    const parsed = cleaned.split(',').map((p) => parseFloat(p.trim()));
+    if (parsed.length < minSize || parsed.some((v) => isNaN(v)))
+        return null;
+    return parsed;
+}

package/dist/drivers/roku/discovery.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rokuPassword = rokuPassword;
+exports.discoverRokuDevices = discoverRokuDevices;
+exports.describe = describe;
+exports.isPortOpen = isPortOpen;
+exports.parseSsdpLocation = parseSsdpLocation;
+/**
+ * Discovers Roku devices on the local network. Two best-effort methods:
+ *  1. `CONDUCTOR_ROKU_HOST` — a manually pinned device IP/hostname (always checked).
+ *  2. SSDP multicast (`M-SEARCH` with `ST: roku:ecp`) — opt-in via
+ *     `CONDUCTOR_ROKU_DISCOVERY`, because the scan multicasts on the LAN and adds
+ *     ~1s to every device listing.
+ */
+const dgram_1 = __importDefault(require("dgram"));
+const net_1 = __importDefault(require("net"));
+const verbose_js_1 = require("../../verbose.js");
+const ecp_client_js_1 = require("./ecp-client.js");
+const SSDP_ADDRESS = '239.255.255.250';
+const SSDP_PORT = 1900;
+const SSDP_TIMEOUT_MS = 1000;
+const PROBE_TIMEOUT_MS = 500;
+/** The dev-mode password used for screenshots, from the environment. */
+function rokuPassword() {
+    return process.env.CONDUCTOR_ROKU_PASSWORD ?? '';
+}
+function discoveryEnabled() {
+    const v = (process.env.CONDUCTOR_ROKU_DISCOVERY ?? '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+}
+/** All Roku devices reachable right now: the pinned env-var host plus any SSDP hits. */
+async function discoverRokuDevices() {
+    const hosts = new Set();
+    const pinned = process.env.CONDUCTOR_ROKU_HOST?.trim();
+    if (pinned)
+        hosts.add(pinned);
+    if (discoveryEnabled()) {
+        for (const host of await ssdpScan())
+            hosts.add(host);
+    }
+    const described = await Promise.all([...hosts].map((host) => describe(host)));
+    return described.filter((d) => d !== null);
+}
+/** Resolve a host into a described device, or null if it isn't reachable. */
+async function describe(host) {
+    if (!(await isPortOpen(host, ecp_client_js_1.DEFAULT_ECP_PORT))) {
+        (0, verbose_js_1.log)(`roku: device at ${host} is not reachable on port ${ecp_client_js_1.DEFAULT_ECP_PORT}`);
+        return null;
+    }
+    const info = await new ecp_client_js_1.RokuEcpClient(host).getDeviceInfo();
+    return {
+        host,
+        modelName: info?.modelName ?? 'Roku Device',
+        friendlyName: info?.friendlyName || host,
+        serialNumber: info?.serialNumber ?? '',
+        softwareVersion: info?.softwareVersion ?? '',
+    };
+}
+/** Quick TCP probe so an offline pinned host fails in ~500ms, not a full HTTP timeout. */
+function isPortOpen(host, port) {
+    return new Promise((resolve) => {
+        const socket = new net_1.default.Socket();
+        const done = (result) => {
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(PROBE_TIMEOUT_MS);
+        socket.once('connect', () => done(true));
+        socket.once('timeout', () => done(false));
+        socket.once('error', () => done(false));
+        socket.connect(port, host);
+    });
+}
+/** SSDP M-SEARCH for `roku:ecp` targets; resolves to the responding hosts. */
+function ssdpScan() {
+    const request = Buffer.from([
+        'M-SEARCH * HTTP/1.1',
+        `HOST: ${SSDP_ADDRESS}:${SSDP_PORT}`,
+        'MAN: "ssdp:discover"',
+        'ST: roku:ecp',
+        'MX: 1',
+        '',
+        '',
+    ].join('\r\n'));
+    return new Promise((resolve) => {
+        const hosts = new Set();
+        const socket = dgram_1.default.createSocket({ type: 'udp4', reuseAddr: true });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                socket.close();
+            }
+            catch {
+                /* already closed */
+            }
+            resolve([...hosts]);
+        };
+        const timer = setTimeout(finish, SSDP_TIMEOUT_MS);
+        socket.on('message', (msg) => {
+            const host = parseSsdpLocation(msg.toString('utf-8'));
+            if (host)
+                hosts.add(host);
+        });
+        socket.on('error', (err) => {
+            (0, verbose_js_1.log)(`roku: SSDP scan failed: ${err.message}`);
+            finish();
+        });
+        socket.bind(() => {
+            socket.send(request, SSDP_PORT, SSDP_ADDRESS, (err) => {
+                if (err) {
+                    (0, verbose_js_1.log)(`roku: SSDP send failed: ${err.message}`);
+                    finish();
+                }
+            });
+        });
+    });
+}
+/** Extract the device host from an SSDP response's `LOCATION: http://<ip>:8060/` header. */
+function parseSsdpLocation(response) {
+    const line = response.split(/\r?\n/).find((l) => /^location:/i.test(l));
+    if (!line)
+        return null;
+    try {
+        return new URL(line.slice(line.indexOf(':') + 1).trim()).hostname || null;
+    }
+    catch {
+        return null;
+    }
+}