@houwert/conductor 0.29.3 → 0.30.0

package/dist/drivers/roku.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RokuDriver = void 0;
+/**
+ * Driver client for Roku devices, reached over the network via the External
+ * Control Protocol (ECP — an HTTP REST API on device port 8060). Roku has no
+ * on-device driver process and no local control port; every operation is a
+ * stateless ECP call:
+ *  - view hierarchy from `/query/app-ui` (SceneGraph XML, dev-mode channels only),
+ *    re-emitted as uiautomator XML so the Android element resolver handles it,
+ *  - input via `/keypress/<key>` (D-pad focus navigation — there is no touch),
+ *  - text via character-by-character `LIT_` keypresses,
+ *  - screenshots via the dev web server's `/plugin_inspect` (digest auth with
+ *    `CONDUCTOR_ROKU_PASSWORD`),
+ *  - app lifecycle via `/launch/<channelId>`.
+ *
+ * Physical hardware only — Roku has no emulator. The device must be in developer
+ * mode with "Control by mobile apps" network access set to Permissive.
+ */
+const ecp_client_js_1 = require("./roku/ecp-client.js");
+const discovery_js_1 = require("./roku/discovery.js");
+const key_mapping_js_1 = require("./roku/key-mapping.js");
+const app_ui_parser_js_1 = require("./roku/app-ui-parser.js");
+const utils_js_1 = require("../utils.js");
+const verbose_js_1 = require("../verbose.js");
+const LAUNCH_TIMEOUT_MS = 10000;
+const EXIT_TIMEOUT_MS = 5000;
+const LONG_PRESS_MS = 1000;
+const SWIPE_KEY_PRESSES = 5;
+const UNSUPPORTED = (op) => new Error(`${op} is not supported on roku`);
+class RokuDriver {
+    /** `host` is the bare device IP/hostname, not the `roku:` id. */
+    constructor(host) {
+        this.host = host;
+        this.platform = 'roku';
+        this.deviceDetails = null;
+        this.ecp = new ecp_client_js_1.RokuEcpClient(host, { password: (0, discovery_js_1.rokuPassword)() });
+    }
+    async isAlive() {
+        return this.ecp.isReachable();
+    }
+    async deviceInfo() {
+        const info = await this.resolveDetails();
+        return { widthPixels: info.widthPixels, heightPixels: info.heightPixels };
+    }
+    /** Cached: the hierarchy path reads this, so an uncached miss is an extra round trip per command. */
+    async resolveDetails() {
+        if (this.deviceDetails)
+            return this.deviceDetails;
+        const info = await this.ecp.getDeviceInfo();
+        if (!info)
+            throw new Error(`Failed to read device info from the Roku device at ${this.host}`);
+        this.deviceDetails = info;
+        return info;
+    }
+    // ── Input ──────────────────────────────────────────────────────────────────
+    /** Roku is D-pad based: there is no coordinate tap, so Select activates whatever holds focus. */
+    async tap(_x, _y, duration) {
+        if (duration && duration >= 0.5) {
+            await this.longPress(_x, _y);
+            return;
+        }
+        (0, verbose_js_1.log)('roku: tap() maps to a Select keypress (Roku is D-pad based)');
+        await this.ecp.sendKeypress('Select');
+    }
+    async longPress(_x, _y) {
+        // Some Roku channels respond to a held Select key.
+        await this.ecp.sendKeyDown('Select');
+        await (0, utils_js_1.sleep)(LONG_PRESS_MS);
+        await this.ecp.sendKeyUp('Select');
+    }
+    /**
+     * A swipe on Roku is repeated D-pad presses in the direction the *content*
+     * moves, which is the opposite of the direction the finger travels.
+     */
+    async swipe(startX, startY, endX, endY, _durationMs) {
+        const dx = endX - startX;
+        const dy = endY - startY;
+        const direction = Math.abs(dy) > Math.abs(dx) ? (dy < 0 ? 'up' : 'down') : dx < 0 ? 'left' : 'right';
+        await this.swipeDirection(direction);
+    }
+    async swipeDirection(direction) {
+        const key = (0, key_mapping_js_1.rokuSwipeKey)(direction);
+        for (let i = 0; i < SWIPE_KEY_PRESSES; i++)
+            await this.ecp.sendKeypress(key);
+    }
+    /** Sends a key by its conductor name (e.g. `Remote Dpad Up`). Throws if unmapped. */
+    async pressKeyNamed(name) {
+        const key = (0, key_mapping_js_1.rokuEcpKey)(name);
+        if (!key)
+            throw new Error(`Key "${name}" is not supported on roku`);
+        await this.ecp.sendKeypress(key);
+    }
+    async back() {
+        await this.ecp.sendKeypress('Back');
+    }
+    async inputText(text) {
+        await this.ecp.sendText(text);
+    }
+    async eraseAllText(charactersToErase = 50) {
+        for (let i = 0; i < charactersToErase; i++)
+            await this.ecp.sendKeypress('Backspace');
+    }
+    // ── Inspection ─────────────────────────────────────────────────────────────
+    /** Returns uiautomator-style XML (consumed by the Android element resolver). */
+    async viewHierarchy() {
+        const xml = await this.ecp.getAppUIRaw();
+        if (xml === null) {
+            throw new Error(`Failed to read the view hierarchy from the Roku device at ${this.host}. ` +
+                `Check ECP network access (Settings > System > Advanced system settings > ` +
+                `Control by mobile apps > Network access > Permissive), and note that ` +
+                `/query/app-ui only reports sideloaded dev-mode channels.`);
+        }
+        const info = await this.resolveDetails().catch(() => null);
+        return (0, app_ui_parser_js_1.parseRokuAppUI)(xml, info?.widthPixels, info?.heightPixels);
+    }
+    async screenshot(_opts = {}) {
+        return this.ecp.takeScreenshot();
+    }
+    // ── App lifecycle ──────────────────────────────────────────────────────────
+    /**
+     * Cold launch. ECP has no terminate endpoint and `launch` resumes an already
+     * running channel with its state intact, so exit to the home screen first to
+     * force a restart from the channel's initial state.
+     */
+    async launchApp(appId, args) {
+        if (await this.ecp.isActiveApp(appId)) {
+            await this.ecp.sendKeypress('Home');
+            const exitDeadline = Date.now() + EXIT_TIMEOUT_MS;
+            while (Date.now() < exitDeadline && (await this.ecp.isActiveApp(appId))) {
+                await (0, utils_js_1.sleep)(200);
+            }
+        }
+        await this.ecp.launchChannel(appId, args ?? {});
+        const deadline = Date.now() + LAUNCH_TIMEOUT_MS;
+        let active = false;
+        while (Date.now() < deadline) {
+            if (await this.ecp.isActiveApp(appId)) {
+                active = true;
+                break;
+            }
+            await (0, utils_js_1.sleep)(200);
+        }
+        if (!active) {
+            // Returning here would leave the flow asserting against whatever screen the
+            // device happens to show, failing later with an unrelated message.
+            throw new Error(`Roku channel ${appId} did not become the active app within ${LAUNCH_TIMEOUT_MS}ms. ` +
+                `Check the channel id (a sideloaded channel is \`dev\`) and that it is installed.`);
+        }
+        // Wait for the channel UI to render — a SceneGraph screen with child nodes.
+        while (Date.now() < deadline) {
+            const xml = await this.ecp.getAppUIRaw();
+            if (xml && /<screen\b[^>]*>\s*</.test(xml))
+                return;
+            await (0, utils_js_1.sleep)(500);
+        }
+        (0, verbose_js_1.log)(`roku: channel ${appId} launched but its UI may not be fully rendered`);
+    }
+    /** Roku has no "stop app" ECP endpoint — pressing Home exits the channel. */
+    async stopApp(_appId) {
+        await this.ecp.sendKeypress('Home');
+    }
+    async terminateApp(appId) {
+        await this.stopApp(appId);
+    }
+    async getForegroundApp() {
+        const app = await this.ecp.getActiveApp();
+        if (!app?.id)
+            throw new Error('Could not determine the active Roku channel');
+        return app.id;
+    }
+    /**
+     * Roku deep links are a `contentId` launch parameter on a channel, so a link
+     * needs a channel to open it. Callers pass only a URL, so this targets the
+     * channel already in the foreground — the one the flow is testing.
+     */
+    async openLink(url, appId) {
+        const channel = appId ?? (await this.ecp.getActiveApp())?.id;
+        if (!channel) {
+            throw new Error('open-link on roku needs a channel to open the link in, and none is active. ' +
+                'Launch the channel first (`conductor launch-app <channelId>`), or pass the ' +
+                'link as a launch argument.');
+        }
+        await this.ecp.launchChannel(channel, { contentId: url });
+    }
+    // ── Unsupported on roku (gated with clear errors) ───────────────────────────
+    async installApp(_path) {
+        throw new Error('install-app is not supported on roku — sideload the channel through the ' +
+            "device's developer web server (http://<device-ip>).");
+    }
+    async uninstallApp(_appId) {
+        throw UNSUPPORTED('uninstall-app');
+    }
+    async listInstalledApps() {
+        throw UNSUPPORTED('list-apps');
+    }
+    async clearAppState(_appId) {
+        throw new Error('clear-state is not supported on roku — re-sideload the channel to reset its state.');
+    }
+    async clearKeychain() {
+        // Not applicable on Roku — no-op.
+    }
+    async setLocation(_latitude, _longitude) {
+        throw UNSUPPORTED('set-location');
+    }
+    async setOrientation(_orientation) {
+        // No-op: TVs don't rotate.
+    }
+    async setPermissions(_appId, _permissions) {
+        // No runtime-permission grant primitive on Roku — no-op.
+    }
+    async addMedia(_filePath) {
+        throw UNSUPPORTED('add-media');
+    }
+    async setAirplaneMode(_enabled) {
+        throw UNSUPPORTED('airplane mode');
+    }
+    async getAirplaneMode() {
+        throw UNSUPPORTED('airplane mode');
+    }
+    async gesturePath(_paths) {
+        throw UNSUPPORTED('multi-finger gestures');
+    }
+    async startRecording(_outputPath) {
+        throw UNSUPPORTED('screen recording');
+    }
+    async stopRecording() {
+        throw UNSUPPORTED('screen recording');
+    }
+    async clipboardRead() {
+        throw UNSUPPORTED('clipboard');
+    }
+    async clipboardWrite(_text) {
+        throw UNSUPPORTED('clipboard');
+    }
+}
+exports.RokuDriver = RokuDriver;

package/dist/drivers/vega/page-source-parser.js

@@ -16,10 +16,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVegaPageSource = parseVegaPageSource;
+const xml_js_1 = require("../xml.js");
 const LAUNCHER_APP = 'com.amazon.keplerlauncherapp';
 /** Parse Vega toolkit XML and re-emit it as uiautomator `<node>` XML. */
 function parseVegaPageSource(xml) {
-    const root = parseXml(xml);
+    const root = (0, xml_js_1.parseXml)(xml);
     if (!root)
         return '<?xml version="1.0" encoding="UTF-8"?>\n<hierarchy />';
     const lines = ['<?xml version="1.0" encoding="UTF-8"?>', '<hierarchy>'];
@@ -53,13 +54,13 @@ function emitNode(node, lines, depth) {
     const attrs = [];
     const role = node.attrs['role'];
     if (role)
-        attrs.push(`class="${xmlEscape(role)}"`);
+        attrs.push(`class="${(0, xml_js_1.xmlEscape)(role)}"`);
     const testId = node.attrs['test_id'];
     if (testId)
-        attrs.push(`resource-id="${xmlEscape(testId)}"`);
+        attrs.push(`resource-id="${(0, xml_js_1.xmlEscape)(testId)}"`);
     const label = labelOf(node);
     if (label)
-        attrs.push(`text="${xmlEscape(label)}"`);
+        attrs.push(`text="${(0, xml_js_1.xmlEscape)(label)}"`);
     attrs.push(`bounds="${boundsOf(node)}"`);
     const interactive = isInteractive(node);
     attrs.push(`clickable="${interactive ? 'true' : 'false'}"`);
@@ -113,117 +114,3 @@ function boolAttr(node, name) {
 function intAttr(node, name) {
     return parseInt(node.attrs[name] ?? '', 10) || 0;
 }
-function xmlEscape(s) {
-    return s
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
-// ── Minimal XML parser ────────────────────────────────────────────────────────
-// Handles elements, attributes, text nodes, self-closing tags, and skips the XML
-// declaration / comments. Sufficient for the well-formed toolkit output.
-function parseXml(xml) {
-    let i = 0;
-    const n = xml.length;
-    function skipWhitespace() {
-        while (i < n && /\s/.test(xml[i]))
-            i++;
-    }
-    function parseNode() {
-        // Skip declarations, comments, and processing instructions before the tag.
-        while (i < n) {
-            skipWhitespace();
-            if (xml.startsWith('<?', i)) {
-                i = xml.indexOf('?>', i);
-                i = i === -1 ? n : i + 2;
-                continue;
-            }
-            if (xml.startsWith('<!--', i)) {
-                i = xml.indexOf('-->', i);
-                i = i === -1 ? n : i + 3;
-                continue;
-            }
-            if (xml.startsWith('<!', i)) {
-                i = xml.indexOf('>', i);
-                i = i === -1 ? n : i + 1;
-                continue;
-            }
-            break;
-        }
-        if (i >= n || xml[i] !== '<')
-            return null;
-        i++; // consume '<'
-        // Read tag name
-        const nameStart = i;
-        while (i < n && !/[\s/>]/.test(xml[i]))
-            i++;
-        const tag = xml.slice(nameStart, i);
-        const attrs = {};
-        // Read attributes
-        while (i < n) {
-            skipWhitespace();
-            if (xml[i] === '/' || xml[i] === '>')
-                break;
-            const attrNameStart = i;
-            while (i < n && !/[\s=/>]/.test(xml[i]))
-                i++;
-            const attrName = xml.slice(attrNameStart, i);
-            skipWhitespace();
-            let attrValue = '';
-            if (xml[i] === '=') {
-                i++; // consume '='
-                skipWhitespace();
-                const quote = xml[i];
-                if (quote === '"' || quote === "'") {
-                    i++;
-                    const valStart = i;
-                    while (i < n && xml[i] !== quote)
-                        i++;
-                    attrValue = xmlUnescape(xml.slice(valStart, i));
-                    i++; // consume closing quote
-                }
-            }
-            if (attrName)
-                attrs[attrName] = attrValue;
-        }
-        const node = { tag, attrs, children: [], text: '' };
-        if (xml[i] === '/') {
-            // self-closing
-            i = xml.indexOf('>', i);
-            i = i === -1 ? n : i + 1;
-            return node;
-        }
-        i++; // consume '>'
-        // Read children / text until closing tag
-        while (i < n) {
-            if (xml.startsWith('</', i)) {
-                i = xml.indexOf('>', i);
-                i = i === -1 ? n : i + 1;
-                break;
-            }
-            if (xml[i] === '<') {
-                const child = parseNode();
-                if (child)
-                    node.children.push(child);
-            }
-            else {
-                const textStart = i;
-                while (i < n && xml[i] !== '<')
-                    i++;
-                node.text += xmlUnescape(xml.slice(textStart, i));
-            }
-        }
-        return node;
-    }
-    return parseNode();
-}
-function xmlUnescape(s) {
-    return s
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&apos;/g, "'")
-        .replace(/&amp;/g, '&');
-}

package/dist/drivers/xml.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Minimal XML parser shared by the driver hierarchy adapters (Vega toolkit output,
+ * Roku ECP `app-ui`). Handles elements, attributes, text nodes, self-closing tags,
+ * and skips declarations/comments — sufficient for well-formed device output, and
+ * cheaper than pulling in a dependency for two callers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXml = parseXml;
+exports.childElement = childElement;
+exports.xmlEscape = xmlEscape;
+exports.xmlUnescape = xmlUnescape;
+/** Parse a document and return its root element, or null if there is none. */
+function parseXml(xml) {
+    let i = 0;
+    const n = xml.length;
+    function skipWhitespace() {
+        while (i < n && /\s/.test(xml[i]))
+            i++;
+    }
+    function parseNode() {
+        // Skip declarations, comments, and processing instructions before the tag.
+        while (i < n) {
+            skipWhitespace();
+            if (xml.startsWith('<?', i)) {
+                i = xml.indexOf('?>', i);
+                i = i === -1 ? n : i + 2;
+                continue;
+            }
+            if (xml.startsWith('<!--', i)) {
+                i = xml.indexOf('-->', i);
+                i = i === -1 ? n : i + 3;
+                continue;
+            }
+            if (xml.startsWith('<!', i)) {
+                i = xml.indexOf('>', i);
+                i = i === -1 ? n : i + 1;
+                continue;
+            }
+            break;
+        }
+        if (i >= n || xml[i] !== '<')
+            return null;
+        i++; // consume '<'
+        // Read tag name
+        const nameStart = i;
+        while (i < n && !/[\s/>]/.test(xml[i]))
+            i++;
+        const tag = xml.slice(nameStart, i);
+        const attrs = {};
+        // Read attributes
+        while (i < n) {
+            skipWhitespace();
+            if (xml[i] === '/' || xml[i] === '>')
+                break;
+            const attrNameStart = i;
+            while (i < n && !/[\s=/>]/.test(xml[i]))
+                i++;
+            const attrName = xml.slice(attrNameStart, i);
+            skipWhitespace();
+            let attrValue = '';
+            if (xml[i] === '=') {
+                i++; // consume '='
+                skipWhitespace();
+                const quote = xml[i];
+                if (quote === '"' || quote === "'") {
+                    i++;
+                    const valStart = i;
+                    while (i < n && xml[i] !== quote)
+                        i++;
+                    attrValue = xmlUnescape(xml.slice(valStart, i));
+                    i++; // consume closing quote
+                }
+            }
+            if (attrName)
+                attrs[attrName] = attrValue;
+        }
+        const node = { tag, attrs, children: [], text: '' };
+        if (xml[i] === '/') {
+            // self-closing
+            i = xml.indexOf('>', i);
+            i = i === -1 ? n : i + 1;
+            return node;
+        }
+        i++; // consume '>'
+        // Read children / text until closing tag
+        while (i < n) {
+            if (xml.startsWith('</', i)) {
+                i = xml.indexOf('>', i);
+                i = i === -1 ? n : i + 1;
+                break;
+            }
+            if (xml[i] === '<') {
+                const child = parseNode();
+                if (child)
+                    node.children.push(child);
+            }
+            else {
+                const textStart = i;
+                while (i < n && xml[i] !== '<')
+                    i++;
+                node.text += xmlUnescape(xml.slice(textStart, i));
+            }
+        }
+        return node;
+    }
+    return parseNode();
+}
+/** First direct child element with the given tag name. */
+function childElement(parent, tag) {
+    return parent.children.find((c) => c.tag === tag);
+}
+function xmlEscape(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function xmlUnescape(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}

package/dist/enum-options.js

@@ -24,7 +24,7 @@ exports.ENUM_PARAMS = [
         param: '<key>',
         description: 'Key, hardware button, or remote button to press',
         values: press_key_js_1.VALID_KEYS.map((value) => ({ value })),
-        note: 'Matched case-insensitively. Availability varies by platform: "Remote …" / "TV …" keys target tvOS, Android TV, and vega (Amazon Fire TV); hardware buttons (Home, Lock, Power, Volume…) target iOS/Android.',
+        note: 'Matched case-insensitively. Availability varies by platform: "Remote …" / "TV …" keys target tvOS, Android TV, vega (Amazon Fire TV), and roku; hardware buttons (Home, Lock, Power, Volume…) target iOS/Android.',
     },
     {
         command: 'scroll',
@@ -62,6 +62,7 @@ exports.ENUM_PARAMS = [
             { value: 'tvos' },
             { value: 'web' },
             { value: 'vega' },
+            { value: 'roku' },
         ],
     },
     {
@@ -110,6 +111,7 @@ exports.ENUM_PARAMS = [
             { value: 'tvos' },
             { value: 'web' },
             { value: 'vega' },
+            { value: 'roku' },
         ],
     },
 ];

package/dist/index.js

@@ -176,7 +176,7 @@ const COMMAND_HELP = {
 const OPTIONS_HELP = `Options:
   --device <id>     Target device ID (also keys the session and daemon)
   --device-name <n> Target a booted device by name (resolved to ID from booted devices)
-  --platform <p>    Filter to devices of this platform (ios, android, tvos, web, vega)
+  --platform <p>    Filter to devices of this platform (ios, android, tvos, web, vega, roku)
   --cdp-url <url>   Attach the web driver to an existing browser over CDP (e.g. an
                     Electron app started with --remote-debugging-port). Remembered per session.
   --cdp-target <id> Pick which CDP page target to control (see \`conductor web-targets\`)

package/dist/runner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectFirstDevice = detectFirstDevice;
+exports.rokuHost = rokuHost;
 exports.getDriver = getDriver;
 exports.prewarmDriver = prewarmDriver;
 exports.inputServerInfo = inputServerInfo;
@@ -18,6 +19,8 @@ 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 cli_js_1 = require("./drivers/vega/cli.js");
+const roku_js_1 = require("./drivers/roku.js");
+const discovery_js_1 = require("./drivers/roku/discovery.js");
 const bootstrap_js_1 = require("./drivers/bootstrap.js");
 const client_js_1 = require("./daemon/client.js");
 /**
@@ -93,6 +96,14 @@ async function detectFirstDevice() {
     catch {
         /* vega CLI not installed */
     }
+    // Roku: pinned via CONDUCTOR_ROKU_HOST (or an opt-in SSDP scan). Best-effort —
+    // neither is configured unless the user set up a Roku device.
+    const roku = (await (0, discovery_js_1.discoverRokuDevices)().catch(() => []))[0];
+    if (roku) {
+        (0, verbose_js_1.log)(`detectFirstDevice: found Roku device "${roku.host}"`);
+        _cachedDeviceId = `roku:${roku.host}`;
+        return _cachedDeviceId;
+    }
     _cachedDeviceId = null;
     return undefined;
 }
@@ -100,6 +111,10 @@ async function detectFirstDevice() {
 function vegaSerial(deviceId) {
     return deviceId.startsWith('vega:') ? deviceId.slice('vega:'.length) : deviceId;
 }
+/** Strip the `roku:` prefix to recover the bare device host. */
+function rokuHost(deviceId) {
+    return deviceId.startsWith('roku:') ? deviceId.slice('roku:'.length) : deviceId;
+}
 /** Per-session driver cache (process lifetime). */
 const _driverCache = new Map();
 /**
@@ -199,6 +214,23 @@ async function getDriver(sessionName = 'default') {
         }
         driver = vegaDriver;
     }
+    else if (platform === 'roku') {
+        // Roku has no driver process and no daemon: control is ECP over the network,
+        // and the device exposes no log stream to collect.
+        const host = rokuHost(deviceId);
+        if (!host || host === 'roku') {
+            throw new Error('No Roku device specified. Set CONDUCTOR_ROKU_HOST=<device-ip>, or pass ' +
+                '--device roku:<device-ip>.');
+        }
+        const rokuDriver = new roku_js_1.RokuDriver(host);
+        if (!(await rokuDriver.isAlive())) {
+            throw new Error(`Cannot reach the Roku device at ${host} on ECP port 8060.\n` +
+                `Check that it is on this network and in developer mode, and that ` +
+                `Settings > System > Advanced system settings > Control by mobile apps > ` +
+                `Network access is set to "Permissive".`);
+        }
+        driver = rokuDriver;
+    }
     else {
         // Ensure the daemon is running — it handles APK install and driver startup.
         await (0, client_js_1.startDaemon)(deviceId);

package/package.json

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

package/skills/conductor-device-interact/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conductor-device-interact
-description: Drive a running iOS simulator, Android emulator, tvOS simulator, Vega (Amazon Fire TV) virtual device, or Playwright web app with the conductor CLI. Use when launching apps, tapping UI elements (by selector or raw coordinate), typing text, scrolling/swiping, performing gestures, pressing hardware/keyboard/remote keys, opening URLs or deep links, navigating back, granting/denying app permissions, adding media to the gallery, setting GPS location or a travel route, toggling airplane mode, recording a screen video, or verifying an app change in the real running app.
+description: Drive a running iOS simulator, Android emulator, tvOS simulator, Vega (Amazon Fire TV) virtual device, Roku device, or Playwright web app with the conductor CLI. Use when launching apps, tapping UI elements (by selector or raw coordinate), typing text, scrolling/swiping, performing gestures, pressing hardware/keyboard/remote keys, opening URLs or deep links, navigating back, granting/denying app permissions, adding media to the gallery, setting GPS location or a travel route, toggling airplane mode, recording a screen video, or verifying an app change in the real running app.
 ---
 
 # Conductor — device interaction
@@ -41,7 +41,7 @@ conductor assert-visible "Dashboard"
 | `conductor copy-text-from <element>` | Print an element's text (and copy to the iOS clipboard) |
 | `conductor input-text <text>` | Type into the focused field |
 | `conductor erase-text [n]` | Erase n characters (default 50) |
-| `conductor press-key <key>` | Press a key (Enter, Backspace, Home, …) or a remote button (`Remote Dpad Up/Down/Left/Right/Center`, `Remote Menu`) for tvOS / Android TV / vega. `--long-press` / `--duration <seconds>` holds it; `--measure` times the response (see `conductor-profiler`) |
+| `conductor press-key <key>` | Press a key (Enter, Backspace, Home, …) or a remote button (`Remote Dpad Up/Down/Left/Right/Center`, `Remote Menu`) for tvOS / Android TV / vega / roku. `--long-press` / `--duration <seconds>` holds it; `--measure` times the response (see `conductor-profiler`) |
 | `conductor hide-keyboard` | Dismiss the on-screen keyboard |
 | `conductor back` | Press back |
 | `conductor scroll [--direction down\|up\|left\|right]` | Scroll |
@@ -125,8 +125,9 @@ relaunch without the flag. (See `conductor-device-setup`.)
 
 ## Tips
 
-- `--device <id>` / `--device-name <name>` targets a device; `--platform <ios|android|tvos|web|vega>` scopes by platform.
+- `--device <id>` / `--device-name <name>` targets a device; `--platform <ios|android|tvos|web|vega|roku>` scopes by platform.
 - Vega (Amazon Fire TV) is D-pad driven: navigate with `press-key "Remote Dpad …"`; coordinate `tap-on` also works. `open-link`, `set-location`, gestures, and clipboard are unsupported. See `conductor-device-setup`.
+- Roku is D-pad only — there is no touch. `tap-on <selector>` resolves the element but presses `Select`, which activates whatever currently holds **focus**, so navigate focus onto the target with `press-key "Remote Dpad …"` first and use `tap-on` to confirm. `scroll`/`swipe` become repeated D-pad presses in the direction the content moves. `open-link` needs an app id (it becomes a channel launch parameter). Only sideloaded dev-mode channels are inspectable. See `conductor-device-setup`.
 - Add `--json` for machine-readable output; failed assertions exit non-zero.
 - Run a per-session daemon for many commands (see `conductor-device-setup`).
 - `conductor <command> --help` for exact flags.