@houwert/conductor 0.29.2 → 0.30.0

package/dist/commands/profile.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REACT_PROFILER_STOP = exports.REACT_PROFILER_READ = exports.REACT_PROFILER_INSTALL = exports.HELP = void 0;
+exports.isUnsymbolised = isUnsymbolised;
+exports.rollupByDso = rollupByDso;
+exports.unsymbolisedPercent = unsymbolisedPercent;
 exports.parseSimpleperfReport = parseSimpleperfReport;
 exports.profileCpu = profileCpu;
 exports.heapGrowth = heapGrowth;
@@ -37,9 +40,80 @@ const output_js_1 = require("../output.js");
 const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const sdk_js_1 = require("../android/sdk.js");
 const runner_js_1 = require("../runner.js");
+const device_js_1 = require("../android/device.js");
 const memory_js_1 = require("./memory.js");
 const metro_cdp_js_1 = require("../drivers/metro-cdp.js");
 const profile_gc_js_1 = require("./profile-gc.js");
+/** simpleperf renders an unresolved address as `libfoo.so[+1a62f8]`. */
+function isUnsymbolised(symbol) {
+    return /\[\+[0-9a-fx]+\]\s*$/i.test(symbol);
+}
+function shortDso(dso) {
+    return dso.includes('/') ? dso.slice(dso.lastIndexOf('/') + 1) : dso;
+}
+/**
+ * Sum a flat symbol table by library.
+ *
+ * A stripped app library shows up as a dozen `libfoo.so[+offset]` rows that a
+ * reader cannot tell apart from a dozen unrelated hotspots. Rolled up, one
+ * library dominating is immediately visible — which is the actual finding when
+ * a profile has no single hot symbol.
+ */
+function rollupByDso(entries) {
+    const byDso = new Map();
+    for (const e of entries) {
+        const key = shortDso(e.dso);
+        const slot = byDso.get(key) ?? { percent: 0, symbols: 0, unsym: 0 };
+        slot.percent += e.percent;
+        slot.symbols++;
+        if (isUnsymbolised(e.symbol))
+            slot.unsym++;
+        byDso.set(key, slot);
+    }
+    return [...byDso.entries()]
+        .map(([dso, v]) => ({
+        dso,
+        percent: Math.round(v.percent * 100) / 100,
+        symbols: v.symbols,
+        unsymbolised: v.unsym === v.symbols,
+    }))
+        .sort((a, b) => b.percent - a.percent);
+}
+/** Share of the sampled overhead that resolved to no function name. */
+function unsymbolisedPercent(entries) {
+    const total = entries.reduce((a, e) => a + e.percent, 0);
+    if (total <= 0)
+        return 0;
+    const unsym = entries.filter((e) => isUnsymbolised(e.symbol)).reduce((a, e) => a + e.percent, 0);
+    return Math.round((unsym / total) * 10000) / 100;
+}
+/**
+ * Turn a simpleperf failure into something actionable.
+ *
+ * simpleperf needs the target to be `android:debuggable` or to declare
+ * `<profileable android:shell="true"/>`. A stock release APK is neither, and
+ * the resulting error says only `exited with 1`.
+ */
+async function explainSimpleperfFailure(deviceId, appId, stderr) {
+    // Drop simpleperf's PMU probing chatter; it is present on every run.
+    const meaningful = stderr
+        .split(/\r?\n/)
+        .filter((l) => l.trim() && !/cannot read event type|Failed to read event type/i.test(l))
+        .slice(-4)
+        .join('\n');
+    if (appId) {
+        const pkg = await (0, device_js_1.adbShell)(deviceId, ['dumpsys', 'package', appId]);
+        if (pkg.success && /^\s*flags=\[/m.test(pkg.stdout) && !/\bDEBUGGABLE\b/.test(pkg.stdout)) {
+            return (`simpleperf cannot profile ${appId}: the installed APK is neither debuggable nor ` +
+                `profileable.\nsimpleperf needs android:debuggable, or ` +
+                `\`<profileable android:shell="true"/>\` inside <application> — the latter is a ` +
+                `one-line manifest change that keeps the build a release build and is the right fix ` +
+                `for a perf build.\n` +
+                (meaningful ? `simpleperf said:\n${meaningful}` : ''));
+        }
+    }
+    return `simpleperf record failed.\n${meaningful || '(no diagnostic output)'}`;
+}
 /**
  * Parse `simpleperf report --sort dso,symbol`. The header row is located by its
  * `Overhead` column rather than by line number, since simpleperf prefixes the
@@ -105,11 +179,13 @@ async function recordAndroidCpu(deviceId, appId, durationSec, out, report) {
     else {
         recordArgs.push('-a');
     }
-    await new Promise((resolve, reject) => {
-        const proc = (0, child_process_1.spawn)(adb, recordArgs, { stdio: 'inherit', env });
-        proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`simpleperf record exited with ${code}`)));
-        proc.on('error', reject);
-    });
+    // Capture rather than inherit: simpleperf prints a wall of `cannot read event
+    // type` lines while probing PMU support, and those are not the error. Letting
+    // them through buries whatever actually went wrong.
+    const rec = await (0, runner_js_1.spawnCommand)(adb, recordArgs, { env });
+    if (!rec.success) {
+        throw new Error(await explainSimpleperfFailure(deviceId, appId, rec.stderr));
+    }
     // Symbolize on-device before pulling: /system/bin/simpleperf resolves against
     // the libraries actually loaded there, which a host-side report cannot do
     // without a matching symfs.
@@ -168,6 +244,10 @@ async function profileCpu(opts, sessionName, profileOpts) {
         else if (platform === 'android') {
             entries = await recordAndroidCpu(sessionName, profileOpts.appId, profileOpts.durationSec, out, profileOpts.report ? { top: profileOpts.top ?? 30 } : undefined);
         }
+        else if (platform === 'roku') {
+            (0, output_js_1.printError)('profile cpu is not supported on roku — ECP exposes no CPU counters.', opts);
+            return 1;
+        }
         else if (platform === 'vega') {
             // Vega is Amazon's own OS, not Android — no simpleperf, no dumpsys. A
             // physical Fire TV Stick runs Fire OS (Android) over adb and is a
@@ -182,17 +262,41 @@ async function profileCpu(opts, sessionName, profileOpts) {
             (0, output_js_1.printError)(`profile cpu is not supported on platform ${platform ?? '(unknown)'}`, opts);
             return 1;
         }
+        const byDso = entries ? rollupByDso(entries) : undefined;
+        const unsymPercent = entries ? unsymbolisedPercent(entries) : undefined;
         if (opts.json) {
-            (0, output_js_1.printData)({ out, durationSec: profileOpts.durationSec, platform, symbols: entries }, opts);
+            (0, output_js_1.printData)({
+                out,
+                durationSec: profileOpts.durationSec,
+                platform,
+                symbols: entries,
+                byDso,
+                unsymbolisedPercent: unsymPercent,
+            }, opts);
         }
         else {
             (0, output_js_1.printSuccess)(`profile cpu — recorded ${profileOpts.durationSec}s → ${out}`, opts);
+            if (byDso && byDso.length > 0) {
+                // Lead with the rollup: a flat profile has no hot symbol, and the real
+                // finding is usually which library the samples are spread across.
+                console.log(`\n  by library`);
+                for (const d of byDso.slice(0, 10)) {
+                    console.log(`  ${`${d.percent}%`.padStart(9)}  ${d.dso}  (${d.symbols} symbol${d.symbols === 1 ? '' : 's'}` +
+                        `${d.unsymbolised ? ', unsymbolised' : ''})`);
+                }
+            }
             if (entries) {
-                console.log(`  ${'overhead'.padStart(9)}  symbol`);
+                console.log(`\n  ${'overhead'.padStart(9)}  symbol`);
                 for (const e of entries) {
                     console.log(`  ${`${e.percent}%`.padStart(9)}  ${e.symbol}  [${e.dso}]`);
                 }
             }
+            if (unsymPercent !== undefined && unsymPercent > 10) {
+                console.log(`\n  note: ${unsymPercent}% of sampled overhead resolved to a raw address rather ` +
+                    `than a function — those libraries are stripped. Read the by-library rollup above ` +
+                    `instead of the symbol table; a dozen \`lib.so[+offset]\` rows are one library, ` +
+                    `not a dozen findings.`);
+            }
         }
         return 0;
     }

package/dist/commands/screenshot.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 png_crop_js_1 = require("../png-crop.js");
@@ -85,8 +86,10 @@ async function screenshot(outputPath, opts = {}, sessionName = 'default', fullPa
                 hierarchyH = info.heightPixels;
                 el = await (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), sel);
             }
-            else if (driver instanceof android_js_1.AndroidDriver || driver instanceof vega_js_1.VegaDriver) {
-                // Vega emits uiautomator-style XML, so it reuses the Android resolver.
+            else if (driver instanceof android_js_1.AndroidDriver ||
+                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.
                 const xml = await driver.viewHierarchy();
                 // Android XML root bounds: derive from the first parseable <node bounds="[0,0][W,H]">
                 const m = xml.match(/<node[^>]*bounds="\[0,0\]\[(\d+),(\d+)\]"/);

package/dist/commands/scroll-until-visible.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 element_resolver_js_1 = require("../drivers/element-resolver.js");
 const direct_ios_selector_js_1 = require("../drivers/direct-ios-selector.js");
 const utils_js_1 = require("../utils.js");
@@ -78,8 +79,10 @@ async function scrollUntilVisible(element, opts = {}, sessionName = 'default', f
                     const { widthPixels: w, heightPixels: h } = info;
                     await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 500);
                 }
-                else if (driver instanceof android_js_1.AndroidDriver || driver instanceof vega_js_1.VegaDriver) {
-                    // Vega emits uiautomator-style XML, so it reuses the Android resolver.
+                else if (driver instanceof android_js_1.AndroidDriver ||
+                    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.
                     const xml = await driver.viewHierarchy();
                     if ((0, element_resolver_js_1.findAndroidElement)(xml, sel)) {
                         (0, output_js_1.printSuccess)(`scroll-until-visible ${label} — found`, opts);

package/dist/commands/scroll.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");
 const utils_js_1 = require("../utils.js");
 async function scroll(direction = 'down', opts = {}, sessionName = 'default') {
     const valid = ['down', 'up', 'left', 'right'];
@@ -32,7 +33,9 @@ async function scroll(direction = 'down', opts = {}, sessionName = 'default') {
             const { widthPixels: w, heightPixels: h } = info;
             await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 500);
         }
-        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 info = await driver.deviceInfo();
             const { widthPixels: w, heightPixels: h } = info;
             await driver.swipe(coords.startX * w, coords.startY * h, coords.endX * w, coords.endY * h, 500);

package/dist/commands/start-device.js

@@ -11,7 +11,7 @@ exports.buildAvdmanagerCreateArgs = buildAvdmanagerCreateArgs;
 exports.raiseAvdConfigRam = raiseAvdConfigRam;
 exports.startDevice = startDevice;
 exports.HELP = `  start-device
-    --platform <ios|android|tvos|web|vega> Boot a simulator/emulator, start the web driver (Playwright), or boot/attach a Vega VVD
+    --platform <ios|android|tvos|web|vega|roku> Boot a simulator/emulator, start the web driver (Playwright), attach a Vega VVD, or check a Roku device
     --os-version <n>                  iOS/tvOS version (e.g. 18) or Android API level (e.g. 33)
     --avd <name>                      Android AVD name (default: first available; created if missing + --device-type)
     --name <name>                     Set a custom name on the device after creation (iOS/tvOS/web)
@@ -34,6 +34,7 @@ const bootstrap_js_1 = require("../drivers/bootstrap.js");
 const output_js_1 = require("../output.js");
 const utils_js_1 = require("../utils.js");
 const cli_js_1 = require("../drivers/vega/cli.js");
+const discovery_js_1 = require("../drivers/roku/discovery.js");
 const IOS_BOOT_TIMEOUT_MS = 120000;
 const ANDROID_BOOT_TIMEOUT_MS = 120000;
 const POLL_MS = 1000;
@@ -807,10 +808,31 @@ async function startVega(opts, deviceName) {
     (0, output_js_1.printSuccess)(`Vega device ready: ${device.serial}`, opts);
     return 0;
 }
+// ── Roku ────────────────────────────────────────────────────────────────────
+/**
+ * Roku is physical hardware with no emulator, so there is nothing to boot: this
+ * resolves the target device (explicit `--name <host>`, else `CONDUCTOR_ROKU_HOST`
+ * or an SSDP hit) and confirms it answers on ECP, so a misconfigured device is
+ * reported here rather than on the first `tap-on`.
+ */
+async function startRoku(opts, deviceName) {
+    const host = deviceName?.replace(/^roku:/, '') ?? process.env.CONDUCTOR_ROKU_HOST?.trim();
+    const device = host ? await (0, discovery_js_1.describe)(host) : (await (0, discovery_js_1.discoverRokuDevices)())[0];
+    if (!device) {
+        (0, output_js_1.printError)(host
+            ? `Cannot reach the Roku device at ${host} on ECP port 8060. Check that it is on ` +
+                `this network and in developer mode.`
+            : 'No Roku device found. Set CONDUCTOR_ROKU_HOST=<device-ip>, pass --name <device-ip>, ' +
+                'or set CONDUCTOR_ROKU_DISCOVERY=true to scan the LAN.', opts);
+        return 1;
+    }
+    (0, output_js_1.printSuccess)(`Roku device ready: ${device.friendlyName || device.modelName} (roku:${device.host})`, opts);
+    return 0;
+}
 // ── Entry point ───────────────────────────────────────────────────────────────
 async function startDevice(platform, opts, flags) {
     if (!platform) {
-        (0, output_js_1.printError)('start-device requires --platform ios|android|tvos|web|vega', opts);
+        (0, output_js_1.printError)('start-device requires --platform ios|android|tvos|web|vega|roku', opts);
         return 1;
     }
     switch (platform.toLowerCase()) {
@@ -824,8 +846,10 @@ async function startDevice(platform, opts, flags) {
             return startWebDriver(opts, flags.browser, flags.name);
         case 'vega':
             return startVega(opts, flags.name);
+        case 'roku':
+            return startRoku(opts, flags.name);
         default:
-            (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios, android, tvos, web, or vega.`, opts);
+            (0, output_js_1.printError)(`Unknown platform "${platform}". Use ios, android, tvos, web, vega, or roku.`, opts);
             return 1;
     }
 }

package/dist/commands/stop-app.js

@@ -10,6 +10,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 stopApp(appId, opts = {}, sessionName = 'default') {
     const session = await (0, session_js_1.getSession)(sessionName);
     const resolvedAppId = appId ?? session.appId;
@@ -24,7 +25,7 @@ async function stopApp(appId, opts = {}, sessionName = 'default') {
         else if (driver instanceof web_js_1.WebDriver) {
             await driver.terminateApp();
         }
-        else if (driver instanceof vega_js_1.VegaDriver) {
+        else if (driver instanceof vega_js_1.VegaDriver || driver instanceof roku_js_1.RokuDriver) {
             await driver.stopApp(resolvedAppId);
         }
         else if (driver instanceof android_js_1.AndroidDriver) {

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
             }