diff --git a/.claude/skills/update-from-upstream/SKILL.md b/.claude/skills/update-from-upstream/SKILL.md
index d5aef74f0c..dbfc569356 100644
--- a/.claude/skills/update-from-upstream/SKILL.md
+++ b/.claude/skills/update-from-upstream/SKILL.md
@@ -28,6 +28,7 @@ The fork adds, on top of upstream Maestro:
 | `feat(orchestra): add readFile command and document fork additions` | `readFile` loads a JSON file into a namespaced object variable (`${data.field}`); adds object-typed JS bindings (`JsEngine.putObjectEnv`) via GraalJS proxies. Also introduces `FORK.md`. |
 | `feat(web): Support attaching to a running Chrome/Electron over CDP` | Attach mode (`--cdp-url` / `--cdp-target`) drives an already-running webview instead of launching Chrome; input routed over CDP since there is no Selenium session. |
 | `chore(fork): add verify-fork-stack skill and resync fork docs` | Fork tooling: the `verify-fork-stack` skill plus the `FORK.md` / stack-table reconciliation it enforces. |
+| `feat(roku): add Roku platform support` | `RokuDriver` over the External Control Protocol (HTTP on device port 8060 — no on-device agent), `RokuEcpClient`/`RokuAppUIParser`/`RokuKeyMapping`, device discovery (`MAESTRO_ROKU_HOST` pin or SSDP scan), `DeviceSpec.Roku`, `RokuLocale`, three new remote KeyCodes (`Remote Info`/`Instant Replay`/`Search`, also mapped on Android), Studio TV mode, and the `e2e/roku_demo_app` fixture. D-pad-only: `tapOn` sends `Select`, swipes are repeated D-pad presses. Unsupported primitives (`setLocation`, `setProxy`, `setDarkMode`, `addMedia`, screen recording) throw or no-op deliberately. Contributed by the Nami team. |
 
 This table is the **fork commit stack** — keyed on commit subject, not SHA (rebasing rewrites SHAs, subjects are stable). Keep it in sync with `git log --oneline upstream/main..main`.
 
diff --git a/AGENTS.md b/AGENTS.md
index b0c09ed428..c5b1a2e220 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,7 +2,7 @@
 
 Shared context for any Claude Code skill or subagent operating in this repo. Skills (`.claude/skills/*`) reference this file rather than restating module roles; if a description here drifts from reality, fix it here once and every skill follows.
 
-> **This is a fork.** [`FORK.md`](FORK.md) lists every capability `plexinc/Maestro` adds on top of upstream — fork-only flow commands (`readFile`, `@alias` path references), platforms (tvOS, Vega/Fire TV), web-driver enhancements, bundled Studio, and distribution. Read it before writing flows or tests so you don't treat fork features as missing or reinvent them. Any new fork-only feature must be documented there in the same commit.
+> **This is a fork.** [`FORK.md`](FORK.md) lists every capability `plexinc/Maestro` adds on top of upstream — fork-only flow commands (`readFile`, `@alias` path references), platforms (tvOS, Vega/Fire TV, Roku), web-driver enhancements, bundled Studio, and distribution. Read it before writing flows or tests so you don't treat fork features as missing or reinvent them. Any new fork-only feature must be documented there in the same commit.
 
 ## Module map
 
@@ -14,7 +14,7 @@ Top-level Gradle modules. Code lives under each module's `src/main/`.
 | `maestro-ios-driver/`        | Host side of iOS driver wrapper (Kotlin). The actual XCTest runner lives in `maestro-ios-xctest-runner/`.                                                                                                                                                                                |
 | `maestro-ios-xctest-runner/` | Swift XCTest runner that runs on the iOS device/simulator. The compiled artifacts (`maestro-driver-ios*.zip`) are checked in under `maestro-ios-driver/src/main/resources/driver-iPhoneSimulator/Debug-iphonesimulator/`.                                                                |
 | `maestro-ios/`               | iOS host-side glue (small — most iOS host code lives in `maestro-client/`).                                                                                                                                                                                                              |
-| `maestro-client/`            | Host-side Kotlin SDK that drives devices. Platform drivers live in `src/main/java/maestro/drivers/`: `AndroidDriver.kt`, `IOSDriver.kt`, `WebDriver.kt`, `CdpWebDriver.kt`. This is where most "auto-grant", "auto-dismiss", system-dialog handling and platform-specific quirks belong. |
+| `maestro-client/`            | Host-side Kotlin SDK that drives devices. Platform drivers live in `src/main/java/maestro/drivers/`: `AndroidDriver.kt`, `IOSDriver.kt`, `WebDriver.kt`, `CdpWebDriver.kt`, `VegaDriver.kt`, `RokuDriver.kt`. This is where most "auto-grant", "auto-dismiss", system-dialog handling and platform-specific quirks belong. |
 | `maestro-orchestra/`         | Command execution layer. `Orchestra.kt` interprets each Maestro command, applies retries, manages the command lifecycle. Sub-packages: `error/`, `filter/`, `workspace/`, `yaml/`.                                                                                                       |
 | `maestro-orchestra-models/`  | Shared command/data models (used by `maestro-orchestra/` and consumers).                                                                                                                                                                                                                 |
 | `maestro-cli/`               | CLI entry point + MCP server. Mixed Kotlin (~100 files) + Swift (~56 files for iOS-related CLI bits).                                                                                                                                                                                    |
diff --git a/FORK.md b/FORK.md
index 3eb5773c51..ce54980043 100644
--- a/FORK.md
+++ b/FORK.md
@@ -113,6 +113,61 @@ Demo app + flows under `e2e/vega_demo_app/` and `e2e/workspaces/vega_demo_app/`.
 Code: `DeviceSpec.Vega`, `maestro/device/DeviceService.kt`, `VegaLocale`.
 Commit `1743bfdf`.
 
+### Roku
+
+Contributed by the [Nami](https://www.nami.ml) team ([rku.dev](https://www.rku.dev)).
+
+Driver for Roku devices over the **External Control Protocol** (ECP — an HTTP
+REST API on device port 8060). Platform id `ROKU` (`--platform roku`). No
+on-device driver process: view hierarchy from `/query/app-ui` (SceneGraph XML,
+dev-mode channels only), D-pad input via `/keypress/<key>`, text via
+character-by-character `LIT_` keypresses, screenshots via the dev web server
+(digest auth), app launch via `/launch/<channelId>`. Roku is D-pad-only — `tapOn`
+sends `Select` (activates the focused element), swipes/scrolls become repeated
+D-pad presses in the direction the *content* moves — `swipe: UP` reveals what is
+below it, so it presses Down, and `scroll` is `swipe: UP`, as on Vega and web.
+`launchApp` is a cold launch: a channel that is already running is exited to the
+home screen first so it restarts from its initial state, and it fails the flow if
+the channel never becomes the active app. A launch (or an `openLink` deep link)
+carries only the parameters the flow asked for.
+
+A rejected ECP command fails the flow rather than logging a warning — otherwise a
+device with ECP access set to anything but Permissive serves `/query/app-ui` while
+403-ing every keypress, and a flow passes green having never touched the device.
+The 403 is reported with that setup hint. Nodes the device isn't rendering
+(`visible="false"`, `opacity="0"`) are dropped from the hierarchy with their
+subtrees, so `assertVisible` won't match a hidden element.
+
+**Device setup** (physical hardware only — Roku has no emulator):
+
+1. Enable developer mode: Home 3x, Up 2x, Right, Left, Right, Left, Right; set a
+   dev password.
+2. Set ECP network access to Permissive: Settings > System > Advanced system
+   settings > Control by mobile apps > Network access > **Permissive** (recent
+   Roku OS versions return 403 on input commands otherwise).
+
+**Device selection** — Roku devices surface through the normal device listing:
+
+```bash
+export MAESTRO_ROKU_HOST=192.168.1.100      # pin a device by IP (primary)
+export MAESTRO_ROKU_PASSWORD=devpwd          # dev-mode password (screenshots only)
+export MAESTRO_ROKU_DISCOVERY=true           # optional: SSDP LAN scan (~1s per listing)
+
+maestro test --platform roku flow.yaml
+maestro test --device 192.168.1.100 flow.yaml
+```
+
+**New KeyCodes** (also mapped on Android): `Remote Info` (the `*` options
+button), `Remote Instant Replay`, `Remote Search`. `Remote Menu` maps to `Info`
+on Roku. Studio's TV mode is auto-on for Roku, like tvOS.
+
+Demo channel + flows under `e2e/roku_demo_app/` (BrightScript; sideload steps in
+the flow headers) and `e2e/workspaces/roku_demo_app/` — mirrors the tvOS/Vega
+demo apps (same screens, labels, and testIDs: Home menu, 2x2 navigation grid,
+native-Keyboard text input, programmatic-focus test).
+Code: `maestro/roku/` (`RokuEcpClient`, `RokuDeviceDiscovery`, `RokuAppUIParser`,
+`RokuKeyMapping`), `drivers/RokuDriver.kt`, `DeviceSpec.Roku`, `RokuLocale`.
+
 ### Web driver enhancements (canvas / D-pad TV web apps)
 
 For D-pad-driven or WebGL/canvas web apps (e.g. Lightning). Platform id `WEB`.
diff --git a/README.md b/README.md
index 89bb02e1dc..2fc10ad75b 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,7 @@
 
 - **Apple TV (tvOS) support** — a tvOS driver, device management (`start-device --platform tvos`), an RN Expo tvOS demo app, and tvOS e2e flows.
 - **Amazon Vega (Fire TV) support** — a driver for Amazon's Vega OS (a Linux/React Native OS, not Android), driven through the `vega`/`vda` CLI: view hierarchy from the on-device automation toolkit, D-pad/touch/swipe/text input, and screenshots.
+- **Roku support** — a driver for Roku devices over the External Control Protocol (an HTTP API on the device, no on-device agent): SceneGraph view hierarchy, D-pad/remote-key input, text entry, screenshots, and network device discovery (`MAESTRO_ROKU_HOST` pin or SSDP scan). Contributed by the [Nami](https://www.nami.ml) team ([rku.dev](https://www.rku.dev)).
 - **Canvas-based UI (web) support** — for D-pad-driven TV web apps (e.g. Lightning/WebGL): `data-testid`-first element selection, D-pad/arrow-key mapping (with Menu→back), URL-shaped `appId` detection, a `focused:` selector, and `--platform web` device selection.
 - **Bundled Maestro Studio, restored and TV-aware** — re-adds the local `maestro studio` web IDE that upstream removed, plus a "TV mode" (auto-on for tvOS, toggleable for web) where taps/swipes and physical arrow keys / Enter / Esc drive the D-pad / select / back.
 - **`major.minor.patch.build` versioning** — `CLI_VERSION` tracks upstream Maestro; a fork-owned `PLEX_BUILD` segment lets us ship fork-only builds without drifting from the inherited version.
diff --git a/e2e/roku_demo_app/components/FocusScreen.brs b/e2e/roku_demo_app/components/FocusScreen.brs
new file mode 100644
index 0000000000..d9c11ca4c6
--- /dev/null
+++ b/e2e/roku_demo_app/components/FocusScreen.brs
@@ -0,0 +1,45 @@
+' Focus — verifies programmatic focus: Button 2 (not the first button) receives
+' focus when the screen opens, the Roku equivalent of the tvOS/Vega screen's
+' requestTVFocus + hasTVPreferredFocus. Same labels and testIDs as those apps.
+sub init()
+    m.buttons = [
+        m.top.findNode("focus-button-1"),
+        m.top.findNode("focus-button-2"),
+        m.top.findNode("back-button")
+    ]
+    m.focusIndex = 1
+
+    m.top.findNode("back-button").observeField("buttonSelected", "onBackSelected")
+    m.top.observeField("visible", "onVisibleChanged")
+end sub
+
+sub onVisibleChanged()
+    if m.top.visible then
+        ' Programmatic focus lands on Button 2, not the first button.
+        m.focusIndex = 1
+        m.buttons[m.focusIndex].setFocus(true)
+    end if
+end sub
+
+sub onBackSelected()
+    m.top.done = true
+end sub
+
+function onKeyEvent(key as string, press as boolean) as boolean
+    if not press then return false
+
+    if key = "back" then
+        m.top.done = true
+        return true
+    else if key = "down" and m.focusIndex < m.buttons.count() - 1 then
+        m.focusIndex = m.focusIndex + 1
+        m.buttons[m.focusIndex].setFocus(true)
+        return true
+    else if key = "up" and m.focusIndex > 0 then
+        m.focusIndex = m.focusIndex - 1
+        m.buttons[m.focusIndex].setFocus(true)
+        return true
+    end if
+
+    return false
+end function
diff --git a/e2e/roku_demo_app/components/FocusScreen.xml b/e2e/roku_demo_app/components/FocusScreen.xml
new file mode 100644
index 0000000000..c8cba7293e
--- /dev/null
+++ b/e2e/roku_demo_app/components/FocusScreen.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="FocusScreen" extends="Group">
+  <script type="text/brightscript" uri="FocusScreen.brs" />
+  <interface>
+    <field id="done" type="boolean" alwaysNotify="true" />
+  </interface>
+  <children>
+    <Label id="titleLabel" text="Focus Test" translation="[100, 60]" />
+    <Button id="focus-button-1" text="Button 1" translation="[100, 160]" minWidth="480" />
+    <Button id="focus-button-2" text="Button 2" translation="[100, 280]" minWidth="480" />
+    <Button id="back-button" text="Back" translation="[100, 400]" minWidth="480" />
+  </children>
+</component>
diff --git a/e2e/roku_demo_app/components/HomeScreen.brs b/e2e/roku_demo_app/components/HomeScreen.brs
new file mode 100644
index 0000000000..f37eb7215f
--- /dev/null
+++ b/e2e/roku_demo_app/components/HomeScreen.brs
@@ -0,0 +1,57 @@
+' Home — vertical menu of buttons that navigate to each test screen.
+' Mirrors the tvOS/Vega HomeScreen (same labels and testIDs).
+sub init()
+    m.buttons = [
+        m.top.findNode("menu-navigation"),
+        m.top.findNode("menu-text-input"),
+        m.top.findNode("menu-focus")
+    ]
+    m.selections = ["navigation", "textinput", "focus"]
+    m.focusIndex = 0
+
+    for each button in m.buttons
+        button.observeField("buttonSelected", "onButtonSelected")
+    end for
+    m.top.observeField("visible", "onVisibleChanged")
+
+    m.buttons[0].setFocus(true)
+end sub
+
+sub focusDefault()
+    m.focusIndex = 0
+    m.buttons[0].setFocus(true)
+end sub
+
+sub onVisibleChanged()
+    if m.top.visible then
+        m.focusIndex = 0
+        m.buttons[0].setFocus(true)
+    end if
+end sub
+
+sub onButtonSelected(event as object)
+    id = event.getRoSGNode().id
+    if id = "menu-navigation" then
+        m.top.selection = "navigation"
+    else if id = "menu-text-input" then
+        m.top.selection = "textinput"
+    else if id = "menu-focus" then
+        m.top.selection = "focus"
+    end if
+end sub
+
+function onKeyEvent(key as string, press as boolean) as boolean
+    if not press then return false
+
+    if key = "down" and m.focusIndex < m.buttons.count() - 1 then
+        m.focusIndex = m.focusIndex + 1
+        m.buttons[m.focusIndex].setFocus(true)
+        return true
+    else if key = "up" and m.focusIndex > 0 then
+        m.focusIndex = m.focusIndex - 1
+        m.buttons[m.focusIndex].setFocus(true)
+        return true
+    end if
+
+    return false
+end function
diff --git a/e2e/roku_demo_app/components/HomeScreen.xml b/e2e/roku_demo_app/components/HomeScreen.xml
new file mode 100644
index 0000000000..d90644a5ee
--- /dev/null
+++ b/e2e/roku_demo_app/components/HomeScreen.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="HomeScreen" extends="Group">
+  <script type="text/brightscript" uri="HomeScreen.brs" />
+  <interface>
+    <field id="selection" type="string" alwaysNotify="true" />
+    <function name="focusDefault" />
+  </interface>
+  <children>
+    <Label id="titleLabel" text="Home" translation="[100, 60]" />
+    <Button id="menu-navigation" text="Navigation Test" translation="[100, 160]" minWidth="520" />
+    <Button id="menu-text-input" text="Text Input Test" translation="[100, 280]" minWidth="520" />
+    <Button id="menu-focus" text="Focus Test" translation="[100, 400]" minWidth="520" />
+  </children>
+</component>
diff --git a/e2e/roku_demo_app/components/MainScene.brs b/e2e/roku_demo_app/components/MainScene.brs
new file mode 100644
index 0000000000..c38306d511
--- /dev/null
+++ b/e2e/roku_demo_app/components/MainScene.brs
@@ -0,0 +1,34 @@
+' Mirrors the tvOS/Vega demo apps (e2e/tvos_demo_app, e2e/vega_demo_app) — same
+' screens, labels and testIDs — re-implemented in BrightScript/SceneGraph. The Home
+' menu opens one test screen at a time; each screen reports "done" to return Home.
+sub init()
+    m.home = m.top.findNode("homeScreen")
+    m.screens = {
+        navigation: m.top.findNode("navigationScreen"),
+        textinput: m.top.findNode("textInputScreen"),
+        focus: m.top.findNode("focusScreen")
+    }
+
+    m.home.observeField("selection", "onMenuSelection")
+    for each name in m.screens
+        m.screens[name].observeField("done", "onScreenDone")
+    end for
+
+    ' Creating the (hidden) TextInputScreen's Keyboard can grab input focus after
+    ' HomeScreen's init already claimed it — re-assert the default focus last.
+    m.home.callFunc("focusDefault")
+end sub
+
+sub onMenuSelection(event as object)
+    target = m.screens[event.getData()]
+    if target = invalid then return
+    m.home.visible = false
+    target.visible = true
+end sub
+
+sub onScreenDone()
+    for each name in m.screens
+        m.screens[name].visible = false
+    end for
+    m.home.visible = true
+end sub
diff --git a/e2e/roku_demo_app/components/MainScene.xml b/e2e/roku_demo_app/components/MainScene.xml
new file mode 100644
index 0000000000..6fa1b2c9db
--- /dev/null
+++ b/e2e/roku_demo_app/components/MainScene.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="MainScene" extends="Scene">
+  <script type="text/brightscript" uri="MainScene.brs" />
+  <children>
+    <HomeScreen id="homeScreen" />
+    <NavigationScreen id="navigationScreen" visible="false" />
+    <TextInputScreen id="textInputScreen" visible="false" />
+    <FocusScreen id="focusScreen" visible="false" />
+  </children>
+</component>
diff --git a/e2e/roku_demo_app/components/NavigationScreen.brs b/e2e/roku_demo_app/components/NavigationScreen.brs
new file mode 100644
index 0000000000..6dddebe34d
--- /dev/null
+++ b/e2e/roku_demo_app/components/NavigationScreen.brs
@@ -0,0 +1,45 @@
+' Navigation — 2x2 grid for testing directional D-pad navigation, plus a Back
+' button. Mirrors the tvOS/Vega NavigationScreen (same labels and testIDs).
+' SceneGraph has no spatial focus engine, so moves are an explicit transition map.
+sub init()
+    m.transitions = {
+        "grid-top-left":     { right: "grid-top-right",   down: "grid-bottom-left" },
+        "grid-top-right":    { left: "grid-top-left",     down: "grid-bottom-right" },
+        "grid-bottom-left":  { right: "grid-bottom-right", up: "grid-top-left",  down: "back-button" },
+        "grid-bottom-right": { left: "grid-bottom-left",   up: "grid-top-right", down: "back-button" },
+        "back-button":       { up: "grid-bottom-left" }
+    }
+    m.currentId = "grid-top-left"
+
+    m.top.findNode("back-button").observeField("buttonSelected", "onBackSelected")
+    m.top.observeField("visible", "onVisibleChanged")
+end sub
+
+sub onVisibleChanged()
+    if m.top.visible then
+        m.currentId = "grid-top-left"
+        m.top.findNode(m.currentId).setFocus(true)
+    end if
+end sub
+
+sub onBackSelected()
+    m.top.done = true
+end sub
+
+function onKeyEvent(key as string, press as boolean) as boolean
+    if not press then return false
+
+    if key = "back" then
+        m.top.done = true
+        return true
+    end if
+
+    moves = m.transitions[m.currentId]
+    if moves = invalid then return false
+    nextId = moves[key]
+    if nextId = invalid then return false
+
+    m.currentId = nextId
+    m.top.findNode(nextId).setFocus(true)
+    return true
+end function
diff --git a/e2e/roku_demo_app/components/NavigationScreen.xml b/e2e/roku_demo_app/components/NavigationScreen.xml
new file mode 100644
index 0000000000..e10a5623e1
--- /dev/null
+++ b/e2e/roku_demo_app/components/NavigationScreen.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="NavigationScreen" extends="Group">
+  <script type="text/brightscript" uri="NavigationScreen.brs" />
+  <interface>
+    <field id="done" type="boolean" alwaysNotify="true" />
+  </interface>
+  <children>
+    <Label id="titleLabel" text="Navigation Test" translation="[100, 60]" />
+    <Button id="grid-top-left" text="Top Left" translation="[100, 160]" minWidth="480" />
+    <Button id="grid-top-right" text="Top Right" translation="[620, 160]" minWidth="480" />
+    <Button id="grid-bottom-left" text="Bottom Left" translation="[100, 280]" minWidth="480" />
+    <Button id="grid-bottom-right" text="Bottom Right" translation="[620, 280]" minWidth="480" />
+    <Button id="back-button" text="Back" translation="[100, 420]" minWidth="480" />
+  </children>
+</component>
diff --git a/e2e/roku_demo_app/components/TextInputScreen.brs b/e2e/roku_demo_app/components/TextInputScreen.brs
new file mode 100644
index 0000000000..e821ef4ea2
--- /dev/null
+++ b/e2e/roku_demo_app/components/TextInputScreen.brs
@@ -0,0 +1,45 @@
+' Text Input — a native Keyboard node plus a label echoing the typed text.
+' Mirrors the tvOS/Vega TextInputScreen (same labels and testIDs). The Keyboard
+' receives focus on entry so Maestro's inputText (ECP LIT_ keypresses) and
+' eraseText (Backspace) land in it directly, no keyboard-open step needed.
+sub init()
+    m.keyboard = m.top.findNode("text-field")
+    m.typedLabel = m.top.findNode("typed-label")
+    m.backButton = m.top.findNode("back-button")
+
+    m.keyboard.observeField("text", "onTextChanged")
+    m.backButton.observeField("buttonSelected", "onBackSelected")
+    m.top.observeField("visible", "onVisibleChanged")
+end sub
+
+sub onVisibleChanged()
+    if m.top.visible then
+        m.keyboard.text = ""
+        m.keyboard.setFocus(true)
+    end if
+end sub
+
+sub onTextChanged()
+    m.typedLabel.text = "Typed: " + m.keyboard.text
+end sub
+
+sub onBackSelected()
+    m.top.done = true
+end sub
+
+function onKeyEvent(key as string, press as boolean) as boolean
+    if not press then return false
+
+    if key = "back" then
+        m.top.done = true
+        return true
+    else if key = "down" and m.keyboard.hasFocus() then
+        m.backButton.setFocus(true)
+        return true
+    else if key = "up" and m.backButton.hasFocus() then
+        m.keyboard.setFocus(true)
+        return true
+    end if
+
+    return false
+end function
diff --git a/e2e/roku_demo_app/components/TextInputScreen.xml b/e2e/roku_demo_app/components/TextInputScreen.xml
new file mode 100644
index 0000000000..f43d1a5ebb
--- /dev/null
+++ b/e2e/roku_demo_app/components/TextInputScreen.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<component name="TextInputScreen" extends="Group">
+  <script type="text/brightscript" uri="TextInputScreen.brs" />
+  <interface>
+    <field id="done" type="boolean" alwaysNotify="true" />
+  </interface>
+  <children>
+    <Label id="titleLabel" text="Text Input Test" translation="[100, 60]" />
+    <Keyboard id="text-field" translation="[100, 160]" />
+    <Label id="typed-label" text="Typed: " translation="[100, 640]" />
+    <Button id="back-button" text="Back" translation="[100, 720]" minWidth="480" />
+  </children>
+</component>
diff --git a/e2e/roku_demo_app/images/icon_hd.png b/e2e/roku_demo_app/images/icon_hd.png
new file mode 100644
index 0000000000..6dc8c8a5c6
Binary files /dev/null and b/e2e/roku_demo_app/images/icon_hd.png differ
diff --git a/e2e/roku_demo_app/images/splash_hd.png b/e2e/roku_demo_app/images/splash_hd.png
new file mode 100644
index 0000000000..1156271a1c
Binary files /dev/null and b/e2e/roku_demo_app/images/splash_hd.png differ
diff --git a/e2e/roku_demo_app/manifest b/e2e/roku_demo_app/manifest
new file mode 100644
index 0000000000..5db703fdb1
--- /dev/null
+++ b/e2e/roku_demo_app/manifest
@@ -0,0 +1,9 @@
+title=Maestro Roku Demo
+major_version=1
+minor_version=0
+build_version=1
+mm_icon_focus_hd=pkg:/images/icon_hd.png
+mm_icon_focus_sd=pkg:/images/icon_hd.png
+splash_screen_hd=pkg:/images/splash_hd.png
+splash_screen_sd=pkg:/images/splash_hd.png
+ui_resolutions=fhd
diff --git a/e2e/roku_demo_app/source/main.brs b/e2e/roku_demo_app/source/main.brs
new file mode 100644
index 0000000000..a0f3bd1caf
--- /dev/null
+++ b/e2e/roku_demo_app/source/main.brs
@@ -0,0 +1,17 @@
+' Maestro Roku demo channel entry point. The channel's only purpose is to
+' exercise Maestro's Roku driver: D-pad focus movement, Select activation,
+' and view-hierarchy assertions against /query/app-ui.
+sub main()
+    screen = createObject("roSGScreen")
+    m.port = createObject("roMessagePort")
+    screen.setMessagePort(m.port)
+    screen.createScene("MainScene")
+    screen.show()
+
+    while true
+        msg = wait(0, m.port)
+        if type(msg) = "roSGScreenEvent" then
+            if msg.isScreenClosed() then return
+        end if
+    end while
+end sub
diff --git a/e2e/workspaces/roku_demo_app/roku-focus-flow.yaml b/e2e/workspaces/roku_demo_app/roku-focus-flow.yaml
new file mode 100644
index 0000000000..c23914a3ef
--- /dev/null
+++ b/e2e/workspaces/roku_demo_app/roku-focus-flow.yaml
@@ -0,0 +1,37 @@
+# Mirrors e2e/workspaces/vega_demo_app/vega-focus-flow.yaml, adapted for Roku.
+# Verifies that programmatic focus (setFocus on screen entry) lands on Button 2,
+# not the first button. See roku-navigation-flow.yaml for sideload steps.
+appId: dev
+tags:
+  - roku
+  - passing
+---
+- launchApp
+
+# Open the Focus Test screen.
+- assertVisible: "Home"
+- pressKey: "Remote Dpad Down"
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "menu-focus"
+    focused: true
+- pressKey: "Remote Dpad Center"
+- assertVisible: "Focus Test"
+
+# Programmatic focus should have landed on Button 2.
+- assertVisible:
+    id: "focus-button-2"
+    focused: true
+- assertVisible:
+    id: "focus-button-1"
+    focused: false
+
+# Return Home via the Back button.
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "back-button"
+    focused: true
+- pressKey: "Remote Dpad Center"
+- assertVisible:
+    id: "menu-navigation"
+    focused: true
diff --git a/e2e/workspaces/roku_demo_app/roku-navigation-flow.yaml b/e2e/workspaces/roku_demo_app/roku-navigation-flow.yaml
new file mode 100644
index 0000000000..d51101220e
--- /dev/null
+++ b/e2e/workspaces/roku_demo_app/roku-navigation-flow.yaml
@@ -0,0 +1,69 @@
+# Mirrors e2e/workspaces/vega_demo_app/vega-navigation-flow.yaml, adapted for Roku.
+# Runs against the sideloaded e2e/roku_demo_app channel (appId `dev`) on a
+# developer-mode Roku pinned via MAESTRO_ROKU_HOST.
+#
+# Sideload the channel first:
+#   cd e2e/roku_demo_app && zip -r ../roku_demo_app.zip . && \
+#   curl -f -u "rokudev:$MAESTRO_ROKU_PASSWORD" --digest \
+#     -F "mysubmit=Install" -F "archive=@../roku_demo_app.zip" \
+#     "http://$MAESTRO_ROKU_HOST/plugin_install"
+appId: dev
+tags:
+  - roku
+  - passing
+---
+- launchApp
+
+# Home loads with the first menu item focused.
+- assertVisible: "Home"
+- assertVisible:
+    id: "menu-navigation"
+    focused: true
+
+# Navigate down through the menu.
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "menu-text-input"
+    focused: true
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "menu-focus"
+    focused: true
+
+# Navigate back up.
+- pressKey: "Remote Dpad Up"
+- pressKey: "Remote Dpad Up"
+- assertVisible:
+    id: "menu-navigation"
+    focused: true
+
+# Enter the Navigation Test screen.
+- pressKey: "Remote Dpad Center"
+- assertVisible: "Navigation Test"
+- assertVisible:
+    id: "grid-top-left"
+    focused: true
+
+# Move around the 2x2 grid with the D-pad.
+- pressKey: "Remote Dpad Right"
+- assertVisible:
+    id: "grid-top-right"
+    focused: true
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "grid-bottom-right"
+    focused: true
+- pressKey: "Remote Dpad Left"
+- assertVisible:
+    id: "grid-bottom-left"
+    focused: true
+
+# Focus the Back button and return Home.
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "back-button"
+    focused: true
+- pressKey: "Remote Dpad Center"
+- assertVisible:
+    id: "menu-navigation"
+    focused: true
diff --git a/e2e/workspaces/roku_demo_app/roku-text-input-flow.yaml b/e2e/workspaces/roku_demo_app/roku-text-input-flow.yaml
new file mode 100644
index 0000000000..7742884380
--- /dev/null
+++ b/e2e/workspaces/roku_demo_app/roku-text-input-flow.yaml
@@ -0,0 +1,31 @@
+# Mirrors e2e/workspaces/vega_demo_app/vega-text-input-flow.yaml, adapted for Roku.
+# The screen focuses a native Keyboard node on entry, so Maestro's inputText
+# (ECP LIT_ keypresses) and eraseText (Backspace) land in it directly — no
+# keyboard-open step needed. See roku-navigation-flow.yaml for sideload steps.
+appId: dev
+tags:
+  - roku
+  - passing
+---
+- launchApp
+
+# Open the Text Input Test screen.
+- assertVisible: "Home"
+- pressKey: "Remote Dpad Down"
+- assertVisible:
+    id: "menu-text-input"
+    focused: true
+- pressKey: "Remote Dpad Center"
+- assertVisible:
+    id: "text-field"
+    focused: true
+
+# Type into the focused keyboard and verify the label echoes it (spaces + capitals).
+- inputText: "Hello Roku"
+- assertVisible: "Typed: Hello Roku"
+
+# Erase and retype. The count is explicit because every character is a separate ECP
+# Backspace keypress: the default of 50 would spend ~5s clearing 10 characters.
+- eraseText: 12
+- inputText: "Maestro Test"
+- assertVisible: "Typed: Maestro Test"
diff --git a/maestro-cli/src/main/java/maestro/cli/command/StartDeviceCommand.kt b/maestro-cli/src/main/java/maestro/cli/command/StartDeviceCommand.kt
index fa52616c0a..3a4c7312bc 100644
--- a/maestro-cli/src/main/java/maestro/cli/command/StartDeviceCommand.kt
+++ b/maestro-cli/src/main/java/maestro/cli/command/StartDeviceCommand.kt
@@ -129,6 +129,14 @@ class StartDeviceCommand : Callable<Int> {
                     os = deviceOs ?: default.os,
                 )
             }
+            Platform.ROKU -> {
+                val default = DeviceSpec.Roku.DEFAULT
+                DeviceSpec.Roku(
+                    model = deviceModel ?: default.model,
+                    os = deviceOs ?: default.os,
+                    host = default.host,
+                )
+            }
             Platform.WEB -> {
                 val default = DeviceSpec.Web.DEFAULT
                 DeviceSpec.Web(
diff --git a/maestro-cli/src/main/java/maestro/cli/device/DeviceCreateUtil.kt b/maestro-cli/src/main/java/maestro/cli/device/DeviceCreateUtil.kt
index 56de18226c..d7e1c6e702 100644
--- a/maestro-cli/src/main/java/maestro/cli/device/DeviceCreateUtil.kt
+++ b/maestro-cli/src/main/java/maestro/cli/device/DeviceCreateUtil.kt
@@ -33,6 +33,23 @@ object DeviceCreateUtil {
             deviceType = Device.DeviceType.EMULATOR,
             deviceSpec = deviceSpec,
         )
+        // Roku devices are physical network devices; nothing to create or boot.
+        // Resolve the target host so `-p roku` works without a create step.
+        is DeviceSpec.Roku    -> {
+            if (deviceSpec.host.isBlank()) {
+                throw CliError(
+                    "No Roku device configured. Set MAESTRO_ROKU_HOST=<device-ip> " +
+                        "(a Roku in developer mode on the same network) and retry."
+                )
+            }
+            Device.AvailableForLaunch(
+                platform = Platform.ROKU,
+                description = "Roku ${deviceSpec.model} (${deviceSpec.host})",
+                modelId = deviceSpec.host,
+                deviceType = Device.DeviceType.REAL,
+                deviceSpec = deviceSpec,
+            )
+        }
     }
 
     fun getOrCreateAppleDevice(
diff --git a/maestro-cli/src/main/java/maestro/cli/device/PickDeviceInteractor.kt b/maestro-cli/src/main/java/maestro/cli/device/PickDeviceInteractor.kt
index f2d32e9158..025918f652 100644
--- a/maestro-cli/src/main/java/maestro/cli/device/PickDeviceInteractor.kt
+++ b/maestro-cli/src/main/java/maestro/cli/device/PickDeviceInteractor.kt
@@ -32,6 +32,7 @@ object PickDeviceInteractor {
                         Platform.ANDROID -> PrintUtils.message("Launching Android emulator...")
                         Platform.IOS, Platform.TVOS -> PrintUtils.message("Launching ${result.platform.description} simulator...")
                         Platform.VEGA -> PrintUtils.message("Using Vega device ${result.description}")
+                        Platform.ROKU -> PrintUtils.message("Connecting to ${result.description}")
                         Platform.WEB -> PrintUtils.message("Launching ${result.description}")
                     }
 
diff --git a/maestro-cli/src/main/java/maestro/cli/device/PickDeviceView.kt b/maestro-cli/src/main/java/maestro/cli/device/PickDeviceView.kt
index 0ada5a0591..471d9b02a0 100644
--- a/maestro-cli/src/main/java/maestro/cli/device/PickDeviceView.kt
+++ b/maestro-cli/src/main/java/maestro/cli/device/PickDeviceView.kt
@@ -23,7 +23,7 @@ object PickDeviceView {
     }
 
     fun requestDeviceOptions(platform: Platform? = null): DeviceSpec {
-        PrintUtils.message("Please specify a device platform [android, ios, tvos, vega, web]:")
+        PrintUtils.message("Please specify a device platform [android, ios, tvos, vega, roku, web]:")
         val selectedPlatform = platform
             ?: (readlnOrNull()?.lowercase()?.let {
                 Platform.fromString(it)
@@ -34,6 +34,7 @@ object PickDeviceView {
             Platform.IOS -> DeviceSpec.Ios.DEFAULT
             Platform.TVOS -> DeviceSpec.Tvos.DEFAULT
             Platform.VEGA -> DeviceSpec.Vega.DEFAULT
+            Platform.ROKU -> DeviceSpec.Roku.DEFAULT
             Platform.WEB -> DeviceSpec.Web.DEFAULT
         }
     }
diff --git a/maestro-cli/src/main/java/maestro/cli/mcp/McpMaestroSessionManager.kt b/maestro-cli/src/main/java/maestro/cli/mcp/McpMaestroSessionManager.kt
index 8c27234d11..c066ef6a39 100644
--- a/maestro-cli/src/main/java/maestro/cli/mcp/McpMaestroSessionManager.kt
+++ b/maestro-cli/src/main/java/maestro/cli/mcp/McpMaestroSessionManager.kt
@@ -16,6 +16,7 @@ import maestro.device.Platform
 import maestro.drivers.AndroidDriver
 import maestro.drivers.CdpWebDriver
 import maestro.drivers.IOSDriver
+import maestro.drivers.RokuDriver
 import maestro.drivers.VegaDriver
 import maestro.vega.VegaDeviceConnection
 import maestro.utils.CliInsights
@@ -76,10 +77,21 @@ internal class McpMaestroSessionManager : AutoCloseable {
             Platform.ANDROID -> createAndroidSession(device, streamDeviceType)
             Platform.IOS, Platform.TVOS -> createIosSession(device, streamDeviceType)
             Platform.VEGA -> createVegaSession(device, streamDeviceType)
+            Platform.ROKU -> createRokuSession(device, streamDeviceType)
             Platform.WEB -> createWebSession()
         }
     }
 
+    private fun createRokuSession(device: Device.Connected, streamDeviceType: StreamDeviceType?): McpMaestroSession {
+        val driver = McpViewerDriver(RokuDriver(host = device.instanceId), "roku")
+        return McpMaestroSession(
+            maestro = Maestro.roku(driver),
+            platform = "roku",
+            streamDeviceType = streamDeviceType,
+            deviceId = device.instanceId,
+        )
+    }
+
     private fun createVegaSession(device: Device.Connected, streamDeviceType: StreamDeviceType?): McpMaestroSession {
         val driver = McpViewerDriver(VegaDriver(VegaDeviceConnection(device.instanceId)), "vega")
         return McpMaestroSession(
diff --git a/maestro-cli/src/main/java/maestro/cli/session/MaestroSessionManager.kt b/maestro-cli/src/main/java/maestro/cli/session/MaestroSessionManager.kt
index fe65c0017b..b36bf47b3d 100644
--- a/maestro-cli/src/main/java/maestro/cli/session/MaestroSessionManager.kt
+++ b/maestro-cli/src/main/java/maestro/cli/session/MaestroSessionManager.kt
@@ -36,6 +36,7 @@ import maestro.cli.report.TestDebugReporter
 import maestro.cli.util.ScreenReporter
 import maestro.drivers.AndroidDriver
 import maestro.drivers.IOSDriver
+import maestro.drivers.RokuDriver
 import maestro.drivers.VegaDriver
 import maestro.vega.VegaDeviceConnection
 import maestro.orchestra.WorkspaceConfig.PlatformConfiguration
@@ -234,6 +235,8 @@ object MaestroSessionManager {
 
                     Platform.VEGA -> createVega(selectedDevice.device.instanceId)
 
+                    Platform.ROKU -> createRoku(selectedDevice.device.instanceId)
+
                     Platform.WEB -> pickWebDevice(isStudio, isHeadless, screenSize, cdpUrl, cdpTarget)
                 },
                 device = selectedDevice.device,
@@ -272,6 +275,11 @@ object MaestroSessionManager {
                 device = null,
             )
 
+            selectedDevice.platform == Platform.ROKU -> MaestroSession(
+                maestro = createRoku(selectedDevice.deviceId ?: error("No Roku device selected")),
+                device = null,
+            )
+
             else -> error("Unable to create Maestro session")
         }
     }
@@ -484,6 +492,12 @@ object MaestroSessionManager {
         return Maestro.vega(driver = VegaDriver(connection))
     }
 
+    private fun createRoku(host: String): Maestro {
+        // The driver picks up the dev-mode password (screenshots only) from
+        // MAESTRO_ROKU_PASSWORD; ECP itself is unauthenticated.
+        return Maestro.roku(driver = RokuDriver(host = host))
+    }
+
     private data class SelectedDevice(
         val platform: Platform,
         val device: Device.Connected? = null,
diff --git a/maestro-client/src/main/java/maestro/KeyCode.kt b/maestro-client/src/main/java/maestro/KeyCode.kt
index 9873e6ebf8..2c2521322c 100644
--- a/maestro-client/src/main/java/maestro/KeyCode.kt
+++ b/maestro-client/src/main/java/maestro/KeyCode.kt
@@ -33,7 +33,10 @@ enum class KeyCode(
     TV_INPUT("TV Input"),
     TV_INPUT_HDMI_1("TV Input HDMI 1"),
     TV_INPUT_HDMI_2("TV Input HDMI 2"),
-    TV_INPUT_HDMI_3("TV Input HDMI 3");
+    TV_INPUT_HDMI_3("TV Input HDMI 3"),
+    REMOTE_INFO("Remote Info"),
+    REMOTE_REPLAY("Remote Instant Replay"),
+    REMOTE_SEARCH("Remote Search");
 
     companion object {
         fun getByName(name: String): KeyCode? {
diff --git a/maestro-client/src/main/java/maestro/Maestro.kt b/maestro-client/src/main/java/maestro/Maestro.kt
index 4d1bcca3a9..7856d89d1e 100644
--- a/maestro-client/src/main/java/maestro/Maestro.kt
+++ b/maestro-client/src/main/java/maestro/Maestro.kt
@@ -809,6 +809,13 @@ class Maestro(
             return Maestro(driver)
         }
 
+        fun roku(driver: Driver, openDriver: Boolean = true): Maestro {
+            if (openDriver) {
+                driver.open()
+            }
+            return Maestro(driver)
+        }
+
         fun web(
             isStudio: Boolean,
             isHeadless: Boolean,
diff --git a/maestro-client/src/main/java/maestro/device/DeviceService.kt b/maestro-client/src/main/java/maestro/device/DeviceService.kt
index aafb78a9de..9a05b6e16d 100644
--- a/maestro-client/src/main/java/maestro/device/DeviceService.kt
+++ b/maestro-client/src/main/java/maestro/device/DeviceService.kt
@@ -8,6 +8,7 @@ import maestro.device.locale.IosLocale
 import maestro.device.util.PrintUtils
 import maestro.drivers.AndroidDriver
 import maestro.drivers.CdpWebDriver
+import maestro.roku.RokuDeviceDiscovery
 import maestro.vega.VegaCli
 import maestro.utils.MaestroTimer
 import maestro.utils.TempFileHandler
@@ -169,6 +170,19 @@ object DeviceService {
                     deviceSpec = device.deviceSpec,
                 )
             }
+
+            Platform.ROKU -> {
+                // Roku devices are physical network devices; there is nothing to boot.
+                // modelId carries the device host — treat it as connected.
+                PrintUtils.message("Connecting to Roku device at ${device.modelId}...")
+                return Device.Connected(
+                    instanceId = device.modelId,
+                    description = device.description,
+                    platform = device.platform,
+                    deviceType = device.deviceType,
+                    deviceSpec = device.deviceSpec,
+                )
+            }
         }
     }
 
@@ -193,6 +207,7 @@ object DeviceService {
         return listAndroidDevices(host, port) +
                 listAppleDevices() +
                 listVegaDevices() +
+                listRokuDevices() +
                 if (includeWeb) {
                     listWebDevices()
                 } else {
@@ -219,6 +234,30 @@ object DeviceService {
         }
     }
 
+    /** Discover Roku devices: the `MAESTRO_ROKU_HOST` pin plus an opt-in SSDP scan
+     * (`MAESTRO_ROKU_DISCOVERY=true`). Best-effort: no configured or responding devices
+     * just yields an empty list rather than failing the whole listing. */
+    fun listRokuDevices(): List<Device> {
+        return runCatching {
+            RokuDeviceDiscovery.discoverDevices().map { roku ->
+                Device.Connected(
+                    instanceId = roku.host,
+                    description = "Roku ${roku.modelName} (${roku.host})",
+                    platform = Platform.ROKU,
+                    deviceType = Device.DeviceType.REAL,
+                    deviceSpec = DeviceSpec.Roku(
+                        model = roku.modelName,
+                        os = "roku-${roku.softwareVersion.ifBlank { "0" }}",
+                        host = roku.host,
+                    ),
+                )
+            }
+        }.getOrElse {
+            logger.warn("Failed to list Roku devices", it)
+            emptyList()
+        }
+    }
+
     fun listWebDevices(): List<Device> {
         return listOf(
             Device.Connected(
diff --git a/maestro-client/src/main/java/maestro/device/DeviceSpec.kt b/maestro-client/src/main/java/maestro/device/DeviceSpec.kt
index 6a0606c5df..fbb1d9d0de 100644
--- a/maestro-client/src/main/java/maestro/device/DeviceSpec.kt
+++ b/maestro-client/src/main/java/maestro/device/DeviceSpec.kt
@@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonTypeInfo
 import maestro.device.locale.AndroidLocale
 import maestro.device.locale.DeviceLocale
 import maestro.device.locale.IosLocale
+import maestro.device.locale.RokuLocale
 import maestro.device.locale.VegaLocale
 import maestro.device.locale.WebLocale
 
@@ -37,6 +38,7 @@ enum class CPU_ARCHITECTURE(val value: String) {
   JsonSubTypes.Type(DeviceSpec.Ios::class, name = "IOS"),
   JsonSubTypes.Type(DeviceSpec.Tvos::class, name = "TVOS"),
   JsonSubTypes.Type(DeviceSpec.Vega::class, name = "VEGA"),
+  JsonSubTypes.Type(DeviceSpec.Roku::class, name = "ROKU"),
   JsonSubTypes.Type(DeviceSpec.Web::class, name = "WEB"),
 )
 sealed class DeviceSpec {
@@ -126,6 +128,31 @@ sealed class DeviceSpec {
         }
     }
 
+    data class Roku(
+        override val model: String,
+        override val os: String,
+        override val locale: RokuLocale = RokuLocale.EN_US,
+        val host: String,
+    ) : DeviceSpec() {
+        init {
+            require(model.isNotBlank()) { "DeviceSpec.Roku: model cannot be blank" }
+            require(os.isNotBlank()) { "DeviceSpec.Roku: os cannot be blank" }
+        }
+
+        override val platform = Platform.ROKU
+        override val osVersion: Int get() = os.removePrefix("roku-").substringBefore(".").toIntOrNull() ?: 0
+        override val deviceName: String get() = "Maestro_ROKU_${model}"
+
+        companion object {
+            /** Host comes from the environment at access time so a late `export` is picked up. */
+            val DEFAULT: Roku get() = Roku(
+                model = "Roku",
+                os = "roku-0",
+                host = System.getenv("MAESTRO_ROKU_HOST") ?: "",
+            )
+        }
+    }
+
     data class Web(
       override val model: String,
       override val os: String,
diff --git a/maestro-client/src/main/java/maestro/device/Platform.kt b/maestro-client/src/main/java/maestro/device/Platform.kt
index 57f002d95c..d7f4716305 100644
--- a/maestro-client/src/main/java/maestro/device/Platform.kt
+++ b/maestro-client/src/main/java/maestro/device/Platform.kt
@@ -5,6 +5,7 @@ enum class Platform(val description: String) {
     IOS("iOS"),
     TVOS("tvOS"),
     VEGA("Vega"),
+    ROKU("Roku"),
     WEB("Web");
 
     companion object {
diff --git a/maestro-client/src/main/java/maestro/device/locale/DeviceLocale.kt b/maestro-client/src/main/java/maestro/device/locale/DeviceLocale.kt
index 7f82f28c56..4e2f8f4e3e 100644
--- a/maestro-client/src/main/java/maestro/device/locale/DeviceLocale.kt
+++ b/maestro-client/src/main/java/maestro/device/locale/DeviceLocale.kt
@@ -36,6 +36,7 @@ sealed interface DeviceLocale {
         Platform.ANDROID -> AndroidLocale.fromString(localeString)
         Platform.IOS, Platform.TVOS -> IosLocale.fromString(localeString)
         Platform.VEGA -> VegaLocale.fromString(localeString)
+        Platform.ROKU -> RokuLocale.fromString(localeString)
         Platform.WEB -> WebLocale.fromString(localeString)
       }
     }
@@ -60,6 +61,7 @@ sealed interface DeviceLocale {
         Platform.ANDROID -> AndroidLocale.all
         Platform.IOS, Platform.TVOS -> IosLocale.entries
         Platform.VEGA -> VegaLocale.entries
+        Platform.ROKU -> RokuLocale.entries
         Platform.WEB -> WebLocale.entries
       }
     }
@@ -72,6 +74,7 @@ sealed interface DeviceLocale {
         Platform.ANDROID -> AndroidLocale.allCodes
         Platform.IOS, Platform.TVOS -> IosLocale.allCodes
         Platform.VEGA -> VegaLocale.allCodes
+        Platform.ROKU -> RokuLocale.allCodes
         Platform.WEB -> WebLocale.allCodes
       }
     }
@@ -85,6 +88,7 @@ sealed interface DeviceLocale {
         Platform.ANDROID -> AndroidLocale.find(languageCode, countryCode)
         Platform.IOS, Platform.TVOS -> IosLocale.find(languageCode, countryCode)
         Platform.VEGA -> VegaLocale.find(languageCode, countryCode)
+        Platform.ROKU -> RokuLocale.find(languageCode, countryCode)
         Platform.WEB -> WebLocale.find(languageCode, countryCode)
       }
     }
@@ -95,6 +99,7 @@ sealed interface DeviceLocale {
         Platform.ANDROID -> AndroidLocale.fromString("en_US")
         Platform.IOS, Platform.TVOS -> IosLocale.fromString("en_US")
         Platform.VEGA -> VegaLocale.fromString("en_US")
+        Platform.ROKU -> RokuLocale.fromString("en_US")
         Platform.WEB -> WebLocale.fromString("en_US")
       }
     }
diff --git a/maestro-client/src/main/java/maestro/device/locale/RokuLocale.kt b/maestro-client/src/main/java/maestro/device/locale/RokuLocale.kt
new file mode 100644
index 0000000000..880004965b
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/device/locale/RokuLocale.kt
@@ -0,0 +1,40 @@
+package maestro.device.locale
+import maestro.device.Platform
+
+/**
+ * Roku device locale. Fixed set for now — Roku locale switching isn't wired up
+ * (ECP has no locale endpoint), so only the default is offered.
+ */
+enum class RokuLocale(override val code: String) : DeviceLocale {
+  EN_US("en_US");
+
+  override val displayName: String
+    get() = DeviceLocale.getDisplayNameFromCode(code)
+
+  override val languageCode: String
+    get() = code.split("_", "-")[0]
+
+  override val countryCode: String
+    get() = code.split("_", "-")[1]
+
+  override val platform: Platform = Platform.ROKU
+
+  companion object {
+    val allCodes: Set<String>
+      get() = entries.map { it.code }.toSet()
+
+    fun fromString(localeString: String): RokuLocale {
+      return entries.find { it.code == localeString }
+        ?: throw LocaleValidationException("Failed to validate Roku locale: $localeString. Here is a full list of supported locales: \n\n ${allCodes.joinToString(", ")}")
+    }
+
+    fun isValid(localeString: String): Boolean {
+      return entries.any { it.code == localeString }
+    }
+
+    fun find(languageCode: String, countryCode: String): String? {
+      val underscoreFormat = "${languageCode}_$countryCode"
+      return if (isValid(underscoreFormat)) underscoreFormat else null
+    }
+  }
+}
diff --git a/maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt b/maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt
index 68868ddbd7..1a05d123d9 100644
--- a/maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt
+++ b/maestro-client/src/main/java/maestro/drivers/AndroidDriver.kt
@@ -311,6 +311,9 @@ class AndroidDriver(
                 KeyCode.TV_INPUT_HDMI_1 -> 243
                 KeyCode.TV_INPUT_HDMI_2 -> 244
                 KeyCode.TV_INPUT_HDMI_3 -> 245
+                KeyCode.REMOTE_INFO -> 165 // KEYCODE_INFO
+                KeyCode.REMOTE_REPLAY -> 273 // KEYCODE_MEDIA_SKIP_BACKWARD
+                KeyCode.REMOTE_SEARCH -> 84 // KEYCODE_SEARCH
             }
 
             shell("input keyevent $intCode")
diff --git a/maestro-client/src/main/java/maestro/drivers/RokuDriver.kt b/maestro-client/src/main/java/maestro/drivers/RokuDriver.kt
new file mode 100644
index 0000000000..c55229eee9
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/drivers/RokuDriver.kt
@@ -0,0 +1,354 @@
+package maestro.drivers
+
+import maestro.Capability
+import maestro.DeviceInfo
+import maestro.Driver
+import maestro.KeyCode
+import maestro.Point
+import maestro.ScreenRecording
+import maestro.SwipeDirection
+import maestro.TreeNode
+import maestro.ViewHierarchy
+import maestro.device.DeviceOrientation
+import maestro.device.Platform
+import maestro.roku.RokuAppUIParser
+import maestro.roku.RokuEcpClient
+import maestro.roku.RokuKeyMapping
+import okio.Sink
+import org.slf4j.LoggerFactory
+import java.io.File
+import kotlin.math.abs
+
+/**
+ * Maestro driver 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; every operation is a stateless ECP call:
+ *  - view hierarchy from `/query/app-ui` (SceneGraph XML, dev-mode channels only),
+ *  - 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 the
+ *    developer-mode password, `MAESTRO_ROKU_PASSWORD`),
+ *  - app lifecycle via `/launch/<channelId>`.
+ *
+ * Requires developer mode and "Control by mobile apps" network access set to Permissive.
+ */
+class RokuDriver(
+    private val host: String,
+    private val password: String = System.getenv("MAESTRO_ROKU_PASSWORD") ?: "",
+    private val keypressDelayMs: Long = 100,
+) : Driver {
+
+    private lateinit var ecpClient: RokuEcpClient
+    private var deviceInfo: RokuEcpClient.RokuDeviceInfo? = null
+    private var shutdown = false
+
+    override fun name(): String = "Roku Device ($host)"
+
+    override fun open() {
+        ecpClient = RokuEcpClient(
+            host = host,
+            password = password,
+            keypressDelayMs = keypressDelayMs,
+        )
+
+        if (!ecpClient.isReachable()) {
+            throw IllegalStateException(
+                "Cannot connect to Roku device at $host. " +
+                    "Ensure the device is on the same network and developer mode is enabled."
+            )
+        }
+
+        deviceInfo = ecpClient.getDeviceInfo()
+        logger.info("Connected to Roku device: ${deviceInfo?.friendlyName} (${deviceInfo?.modelName})")
+        shutdown = false
+    }
+
+    override fun close() {
+        if (::ecpClient.isInitialized) {
+            ecpClient.close()
+        }
+        shutdown = true
+    }
+
+    override fun deviceInfo(): DeviceInfo {
+        // Cache the retry too: contentDescriptor reads this field on every hierarchy
+        // dump, so an uncached fallback is an extra ECP round trip per command.
+        val info = deviceInfo
+            ?: ecpClient.getDeviceInfo()?.also { deviceInfo = it }
+            ?: throw IllegalStateException("Failed to get Roku device info")
+
+        return DeviceInfo(
+            platform = Platform.ROKU,
+            widthPixels = info.widthPixels,
+            heightPixels = info.heightPixels,
+            widthGrid = info.widthPixels,
+            heightGrid = info.heightPixels,
+        )
+    }
+
+    override fun launchApp(appId: String, launchArguments: Map<String, Any>) {
+        // Maestro's launchApp is a cold launch. ECP has no terminate endpoint and the
+        // launch call 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.
+        if (ecpClient.isActiveApp(appId)) {
+            ecpClient.sendKeypress("Home")
+            val exitDeadline = System.currentTimeMillis() + EXIT_TIMEOUT_MS
+            while (ecpClient.isActiveApp(appId) && System.currentTimeMillis() < exitDeadline) {
+                Thread.sleep(200)
+            }
+        }
+
+        val stringParams = launchArguments.mapValues { it.value.toString() }
+        ecpClient.launchChannel(appId, stringParams)
+
+        // Wait for the channel to become the active app
+        val startTime = System.currentTimeMillis()
+        var appActive = false
+        while (System.currentTimeMillis() - startTime < LAUNCH_TIMEOUT_MS) {
+            if (ecpClient.isActiveApp(appId)) {
+                appActive = true
+                break
+            }
+            Thread.sleep(200)
+        }
+        if (!appActive) {
+            // Returning here would leave the flow asserting against whatever screen the
+            // device happens to be showing, failing later with an unrelated message.
+            throw IllegalStateException(
+                "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 the channel is installed."
+            )
+        }
+
+        // Wait for the app UI to render (a SceneGraph screen with child nodes)
+        while (System.currentTimeMillis() - startTime < LAUNCH_TIMEOUT_MS) {
+            val doc = ecpClient.getAppUI()
+            if (doc != null) {
+                val screens = doc.documentElement?.getElementsByTagName("screen")
+                val screen = if (screens != null && screens.length > 0) {
+                    screens.item(0) as? org.w3c.dom.Element
+                } else null
+                if (screen != null && screen.childNodes.length > 0) {
+                    logger.info("App $appId UI is ready")
+                    return
+                }
+            }
+            Thread.sleep(500)
+        }
+        logger.warn("App $appId launched but UI may not be fully rendered")
+    }
+
+    override fun stopApp(appId: String) {
+        // Roku has no "stop app" ECP endpoint — pressing Home exits the channel
+        ecpClient.sendKeypress("Home")
+    }
+
+    override fun killApp(appId: String) {
+        stopApp(appId)
+    }
+
+    override fun clearAppState(appId: String) {
+        // No supported "clear data" primitive; re-sideloading the channel is the documented reset
+        logger.warn("clearAppState is not supported on Roku; reinstall the channel to reset state")
+    }
+
+    override fun clearKeychain() {
+        // Not applicable on Roku.
+    }
+
+    override fun tap(point: Point) {
+        // Roku is D-pad based; there is no coordinate tap. Select activates the focused element.
+        logger.debug("tap() called on Roku — sending Select keypress (Roku is D-pad based)")
+        ecpClient.sendKeypress("Select")
+    }
+
+    override fun longPress(point: Point) {
+        // Some Roku apps respond to a held Select key.
+        ecpClient.sendKeyDown("Select")
+        Thread.sleep(LONG_PRESS_MS)
+        ecpClient.sendKeyUp("Select")
+    }
+
+    override fun pressKey(code: KeyCode) {
+        val ecpKey = RokuKeyMapping.toEcpKey(code)
+            ?: throw UnsupportedOperationException("KeyCode $code is not supported on Roku")
+        ecpClient.sendKeypress(ecpKey)
+    }
+
+    override fun contentDescriptor(excludeKeyboardElements: Boolean): TreeNode {
+        val document = ecpClient.getAppUI()
+        if (document == null) {
+            logger.warn(
+                "Failed to get app UI from Roku device at $host. " +
+                    "View hierarchy will be empty — assertVisible and other element lookups will fail. " +
+                    "Check ECP network access (Settings > System > Advanced > Control by mobile apps > Permissive)."
+            )
+            return TreeNode(
+                attributes = mutableMapOf(),
+                children = emptyList(),
+                clickable = false,
+                enabled = true,
+                focused = false,
+                checked = null,
+                selected = null,
+            )
+        }
+
+        val info = deviceInfo
+        return if (info != null) {
+            RokuAppUIParser.parse(document, info.widthPixels, info.heightPixels)
+        } else {
+            RokuAppUIParser.parse(document)
+        }
+    }
+
+    override fun scrollVertical() {
+        // Scrolling down the page is a swipe up, as on Vega and web.
+        swipe(SwipeDirection.UP, 0)
+    }
+
+    override fun isKeyboardVisible(): Boolean {
+        // No reliable keyboard-visibility signal; text input targets the focused field via LIT_.
+        return false
+    }
+
+    override fun swipe(start: Point, end: Point, durationMs: Long) {
+        val dx = end.x - start.x
+        val dy = end.y - start.y
+
+        val direction = when {
+            abs(dy) > abs(dx) && dy < 0 -> SwipeDirection.UP
+            abs(dy) > abs(dx) -> SwipeDirection.DOWN
+            dx < 0 -> SwipeDirection.LEFT
+            else -> SwipeDirection.RIGHT
+        }
+        swipe(direction, durationMs)
+    }
+
+    override fun swipe(swipeDirection: SwipeDirection, durationMs: Long) {
+        // 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.
+        val key = RokuKeyMapping.toEcpKey(swipeDirection)
+        repeat(SWIPE_KEY_PRESSES) {
+            ecpClient.sendKeypress(key)
+        }
+    }
+
+    override fun swipe(elementPoint: Point, direction: SwipeDirection, durationMs: Long) {
+        swipe(direction, durationMs)
+    }
+
+    override fun backPress() {
+        ecpClient.sendKeypress("Back")
+    }
+
+    override fun inputText(text: String) {
+        ecpClient.sendText(text)
+    }
+
+    override fun openLink(link: String, appId: String?, autoVerify: Boolean, browser: Boolean) {
+        // Roku deep links are launch parameters on the channel
+        if (appId != null) {
+            ecpClient.launchChannel(appId, mapOf("contentId" to link))
+        } else {
+            throw UnsupportedOperationException("openLink without appId is not supported on Roku")
+        }
+    }
+
+    override fun hideKeyboard() {
+        ecpClient.sendKeypress("Back")
+    }
+
+    override fun takeScreenshot(out: Sink, compressed: Boolean) {
+        ecpClient.takeScreenshot(out)
+    }
+
+    override fun startScreenRecording(out: Sink): ScreenRecording {
+        throw UnsupportedOperationException("Screen recording is not supported on Roku")
+    }
+
+    override fun setLocation(latitude: Double, longitude: Double) {
+        throw UnsupportedOperationException("setLocation is not supported on Roku")
+    }
+
+    override fun setOrientation(orientation: DeviceOrientation) {
+        // no-op: TVs don't rotate.
+    }
+
+    // Roku exposes no theme state over ECP; channels draw their own UI.
+    override fun isDarkModeEnabled(): Boolean = false
+
+    override fun setDarkMode(enabled: Boolean) {
+        throw UnsupportedOperationException("setDarkMode is not supported on Roku")
+    }
+
+    override fun eraseText(charactersToErase: Int) {
+        repeat(charactersToErase) {
+            ecpClient.sendKeypress("Backspace")
+        }
+    }
+
+    override fun setProxy(host: String, port: Int) {
+        throw UnsupportedOperationException("setProxy is not supported on Roku")
+    }
+
+    override fun resetProxy() {
+        // Nothing to reset.
+    }
+
+    override fun isShutdown(): Boolean = shutdown
+
+    override fun waitUntilScreenIsStatic(timeoutMs: Long): Boolean {
+        // Screenshot diffing needs the dev password and is slow on Roku, so poll
+        // /query/app-ui instead: when the XML stops changing, the screen is static.
+        val startTime = System.currentTimeMillis()
+        var previousXml: String? = null
+
+        while (System.currentTimeMillis() - startTime < timeoutMs) {
+            val currentXml = ecpClient.getAppUIRaw()
+            if (currentXml != null && currentXml == previousXml) {
+                return true
+            }
+            previousXml = currentXml
+            Thread.sleep(SCREEN_POLL_INTERVAL_MS)
+        }
+        logger.debug("Screen did not become static within ${timeoutMs}ms")
+        return false
+    }
+
+    override fun waitForAppToSettle(
+        initialHierarchy: ViewHierarchy?,
+        appId: String?,
+        timeoutMs: Int?,
+    ): ViewHierarchy? {
+        val timeout = timeoutMs?.toLong() ?: SETTLE_TIMEOUT_MS
+        waitUntilScreenIsStatic(minOf(timeout, SETTLE_TIMEOUT_MS))
+        return null
+    }
+
+    override fun capabilities(): List<Capability> = emptyList()
+
+    override fun setPermissions(appId: String, permissions: Map<String, String>) {
+        // no-op: Roku has no runtime-permission grant primitive.
+    }
+
+    override fun addMedia(mediaFiles: List<File>) {
+        throw UnsupportedOperationException("addMedia is not supported on Roku")
+    }
+
+    override fun isAirplaneModeEnabled(): Boolean = false
+
+    override fun setAirplaneMode(enabled: Boolean) {
+        throw UnsupportedOperationException("Airplane mode is not supported on Roku")
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(RokuDriver::class.java)
+        private const val LAUNCH_TIMEOUT_MS = 10_000L
+        private const val EXIT_TIMEOUT_MS = 5_000L
+        private const val LONG_PRESS_MS = 1_000L
+        private const val SETTLE_TIMEOUT_MS = 3_000L
+        private const val SCREEN_POLL_INTERVAL_MS = 300L
+        private const val SWIPE_KEY_PRESSES = 5
+    }
+}
diff --git a/maestro-client/src/main/java/maestro/roku/RokuAppUIParser.kt b/maestro-client/src/main/java/maestro/roku/RokuAppUIParser.kt
new file mode 100644
index 0000000000..92fcf75a05
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/roku/RokuAppUIParser.kt
@@ -0,0 +1,217 @@
+package maestro.roku
+
+import maestro.TreeNode
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import org.w3c.dom.Node
+
+/**
+ * Parses Roku's ECP `/query/app-ui` XML response into Maestro's [TreeNode] structure.
+ *
+ * The app-ui response has the following structure:
+ * ```
+ * <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}" ...>
+ *         ...children...
+ *       </RenderableNode>
+ *     </screen>
+ *   </topscreen>
+ * </app-ui>
+ * ```
+ *
+ * Node `name` attributes (the SceneGraph node ids) become `resource-id`; `bounds` are
+ * accumulated with parent `translation` offsets into scene-absolute `[x1,y1][x2,y2]`
+ * rects, matching the Android adapter's format. Nodes the device isn't rendering
+ * (`visible="false"` or `opacity="0"`) are dropped along with their subtrees.
+ *
+ * Reference: roku-test-automation ECP.ts.
+ */
+object RokuAppUIParser {
+
+    fun parse(document: Document, screenWidth: Int = 1920, screenHeight: Int = 1080): TreeNode {
+        val root = document.documentElement
+
+        // Navigate to topscreen > screen > children
+        val topscreen = findChildElement(root, "topscreen")
+        val screen = topscreen?.let { findChildElement(it, "screen") }
+
+        if (screen == null) {
+            return TreeNode(
+                attributes = mutableMapOf("text" to "Roku App UI"),
+                children = emptyList(),
+                clickable = false,
+                enabled = true,
+                focused = false,
+                checked = null,
+                selected = null,
+            )
+        }
+
+        val children = parseChildren(screen, offset = Offset(0.0, 0.0))
+
+        return TreeNode(
+            attributes = mutableMapOf(
+                "text" to "Roku Screen",
+                "bounds" to "[0,0][$screenWidth,$screenHeight]",
+            ),
+            children = children,
+            clickable = false,
+            enabled = true,
+            focused = screen.getAttribute("focused") == "true",
+            checked = null,
+            selected = null,
+        )
+    }
+
+    private fun parseChildren(parent: Element, offset: Offset, parentIsRowListItem: Boolean = false): List<TreeNode> {
+        val childElements = getChildElements(parent)
+
+        // If parent is RowListItem, remove the trailing duplicate Group (RTA pattern)
+        val elements = if (parentIsRowListItem && childElements.size > 1) {
+            childElements.dropLast(1)
+        } else {
+            childElements
+        }
+
+        return elements.mapNotNull { parseNode(it, offset, parentIsRowListItem) }
+    }
+
+    private fun parseNode(element: Element, parentOffset: Offset, parentIsRowListItem: Boolean = false): TreeNode? {
+        val id = element.getAttribute("name").ifEmpty { null }
+        // ECP reports the SceneGraph type in a `subtype` attribute; the element name is
+        // only a fallback, and for a generic `RenderableNode` it says nothing at all.
+        val subtype = element.getAttribute("subtype").ifEmpty {
+            if (element.nodeName == "RenderableNode") "Group" else element.nodeName
+        }
+        val focusable = element.getAttribute("focusable") == "true"
+        val focused = element.getAttribute("focused") == "true"
+        val visible = element.getAttribute("visible") != "false"
+        val opacityStr = element.getAttribute("opacity").ifEmpty { "100" }
+        val opacity = opacityStr.toDoubleOrNull()?.div(100) ?: 1.0
+
+        // SceneGraph doesn't render an invisible node or anything beneath it, but ECP
+        // still reports the subtree with real bounds. Maestro's ViewHierarchy.isVisible
+        // only consults bounds, so keeping those nodes would make assertVisible match a
+        // hidden element and assertNotVisible fail on one.
+        if (!visible || opacity <= 0) return null
+
+        // Arity is enforced on the way in, so every read below is in range.
+        val translation = parseArray(element.getAttribute("translation"), minSize = 2)
+        val bounds = parseArray(element.getAttribute("bounds"), minSize = 4)
+        val text = element.getAttribute("text").ifEmpty { null }
+        val color = element.getAttribute("color").ifEmpty { null }
+        val uri = element.getAttribute("uri").ifEmpty { null }
+
+        // Calculate scene-relative offset that this node's children inherit
+        val nodeOffset = if (subtype == "MarkupGrid" && parentIsRowListItem) {
+            // MarkupGrid under RowListItem: use bounds offset
+            if (bounds != null) {
+                Offset(bounds[0] + parentOffset.x, bounds[1] + parentOffset.y)
+            } else {
+                parentOffset
+            }
+        } else if (translation != null) {
+            Offset(translation[0] + parentOffset.x, translation[1] + parentOffset.y)
+        } else {
+            parentOffset
+        }
+
+        val sceneRect = if (bounds != null) {
+            SceneRect(
+                x = bounds[0] + parentOffset.x,
+                y = bounds[1] + parentOffset.y,
+                width = bounds[2],
+                height = bounds[3],
+            )
+        } else null
+
+        // Build bounds string in Maestro format: [x1,y1][x2,y2]
+        val boundsAttr = sceneRect?.let {
+            val x1 = it.x.toInt()
+            val y1 = it.y.toInt()
+            val x2 = (it.x + it.width).toInt()
+            val y2 = (it.y + it.height).toInt()
+            "[$x1,$y1][$x2,$y2]"
+        }
+
+        val attributes = mutableMapOf<String, String>()
+        if (id != null) attributes["resource-id"] = id
+        if (text != null) attributes["text"] = text
+        if (boundsAttr != null) attributes["bounds"] = boundsAttr
+        if (color != null) attributes["color"] = color
+        if (uri != null) attributes["uri"] = uri
+        attributes["subtype"] = subtype
+
+        val isRowListItem = element.nodeName == "RowListItem"
+        val childElements = getChildElements(element)
+        val children = if (childElements.isNotEmpty()) {
+            parseChildren(element, nodeOffset, parentIsRowListItem = isRowListItem)
+        } else {
+            emptyList()
+        }
+
+        return TreeNode(
+            attributes = attributes,
+            children = children,
+            clickable = focusable,
+            enabled = true,
+            focused = focused,
+            checked = null,
+            selected = focused,
+        )
+    }
+
+    /**
+     * Parses a Roku numeric array attribute, or null if it doesn't hold at least
+     * [minSize] values — a short array is no more usable than a missing one, and
+     * callers index it positionally.
+     */
+    private fun parseArray(value: String?, minSize: Int): DoubleArray? {
+        if (value.isNullOrEmpty()) return null
+        // Roku returns arrays with curly braces: {0, 0, 1920, 1080}
+        val cleaned = value.replace("{", "").replace("}", "").trim()
+        if (cleaned.isEmpty()) return null
+        val parsed = try {
+            cleaned.split(",").map { it.trim().toDouble() }.toDoubleArray()
+        } catch (e: NumberFormatException) {
+            return null
+        }
+        return parsed.takeIf { it.size >= minSize }
+    }
+
+    private fun getChildElements(parent: Element): List<Element> {
+        val result = mutableListOf<Element>()
+        val children = parent.childNodes
+        for (i in 0 until children.length) {
+            val node = children.item(i)
+            if (node.nodeType == Node.ELEMENT_NODE) {
+                result.add(node as Element)
+            }
+        }
+        return result
+    }
+
+    private fun findChildElement(parent: Element, name: String): Element? {
+        val children = parent.childNodes
+        for (i in 0 until children.length) {
+            val node = children.item(i)
+            if (node.nodeType == Node.ELEMENT_NODE && node.nodeName == name) {
+                return node as Element
+            }
+        }
+        return null
+    }
+
+    private data class Offset(val x: Double, val y: Double)
+
+    private data class SceneRect(
+        val x: Double,
+        val y: Double,
+        val width: Double,
+        val height: Double,
+    )
+}
diff --git a/maestro-client/src/main/java/maestro/roku/RokuDeviceDiscovery.kt b/maestro-client/src/main/java/maestro/roku/RokuDeviceDiscovery.kt
new file mode 100644
index 0000000000..9a7146d40f
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/roku/RokuDeviceDiscovery.kt
@@ -0,0 +1,132 @@
+package maestro.roku
+
+import org.slf4j.LoggerFactory
+import java.net.DatagramPacket
+import java.net.DatagramSocket
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.Socket
+import java.net.SocketTimeoutException
+import java.net.URI
+
+/**
+ * Discovers Roku devices on the local network.
+ *
+ * Two discovery methods, both best-effort:
+ * 1. `MAESTRO_ROKU_HOST` — a manually pinned device IP/hostname (primary; always checked).
+ * 2. SSDP multicast (`M-SEARCH` with `ST: roku:ecp`) — opt-in via `MAESTRO_ROKU_DISCOVERY=true`,
+ *    because the scan multicasts on the LAN and adds ~1s to every device listing.
+ */
+object RokuDeviceDiscovery {
+
+    private val logger = LoggerFactory.getLogger(RokuDeviceDiscovery::class.java)
+
+    private const val SSDP_ADDRESS = "239.255.255.250"
+    private const val SSDP_PORT = 1900
+    private const val SSDP_TIMEOUT_MS = 1000
+    private const val PROBE_TIMEOUT_MS = 500
+
+    data class DiscoveredDevice(
+        val host: String,
+        val modelName: String,
+        val friendlyName: String,
+        val serialNumber: String,
+        val softwareVersion: String,
+    )
+
+    /** All Roku devices reachable right now: the pinned env-var host plus any SSDP hits. */
+    fun discoverDevices(): List<DiscoveredDevice> {
+        val hosts = linkedSetOf<String>()
+
+        System.getenv("MAESTRO_ROKU_HOST")?.takeIf { it.isNotBlank() }?.let { hosts.add(it) }
+
+        if (System.getenv("MAESTRO_ROKU_DISCOVERY")?.lowercase() in setOf("1", "true", "yes")) {
+            hosts.addAll(ssdpScan())
+        }
+
+        return hosts.mapNotNull { host -> describe(host) }
+    }
+
+    /** Resolve a host into a described device, or null (with a warning) if unreachable. */
+    private fun describe(host: String): DiscoveredDevice? {
+        if (!isPortOpen(host, RokuEcpClient.DEFAULT_ECP_PORT)) {
+            logger.warn("Roku device at $host is not reachable on port ${RokuEcpClient.DEFAULT_ECP_PORT}")
+            return null
+        }
+        val client = RokuEcpClient(host = host)
+        return try {
+            val info = client.getDeviceInfo()
+            DiscoveredDevice(
+                host = host,
+                modelName = info?.modelName ?: "Roku Device",
+                friendlyName = info?.friendlyName ?: host,
+                serialNumber = info?.serialNumber ?: "",
+                softwareVersion = info?.softwareVersion ?: "",
+            )
+        } finally {
+            client.close()
+        }
+    }
+
+    /** Quick TCP probe so an offline pinned host fails in ~500ms, not a full HTTP timeout. */
+    private fun isPortOpen(host: String, port: Int): Boolean {
+        return try {
+            Socket().use { socket ->
+                socket.connect(InetSocketAddress(host, port), PROBE_TIMEOUT_MS)
+                true
+            }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    /** SSDP M-SEARCH for `roku:ecp` targets; returns the responding hosts. */
+    private fun ssdpScan(): Set<String> {
+        val request = buildString {
+            append("M-SEARCH * HTTP/1.1\r\n")
+            append("HOST: $SSDP_ADDRESS:$SSDP_PORT\r\n")
+            append("MAN: \"ssdp:discover\"\r\n")
+            append("ST: roku:ecp\r\n")
+            append("MX: 1\r\n")
+            append("\r\n")
+        }.toByteArray()
+
+        val hosts = linkedSetOf<String>()
+        try {
+            DatagramSocket().use { socket ->
+                socket.soTimeout = SSDP_TIMEOUT_MS
+                socket.send(DatagramPacket(request, request.size, InetAddress.getByName(SSDP_ADDRESS), SSDP_PORT))
+
+                val buffer = ByteArray(2048)
+                val deadline = System.currentTimeMillis() + SSDP_TIMEOUT_MS
+                while (System.currentTimeMillis() < deadline) {
+                    val packet = DatagramPacket(buffer, buffer.size)
+                    try {
+                        socket.receive(packet)
+                    } catch (e: SocketTimeoutException) {
+                        break
+                    }
+                    val response = String(packet.data, 0, packet.length)
+                    parseSsdpLocation(response)?.let { hosts.add(it) }
+                }
+            }
+        } catch (e: Exception) {
+            logger.warn("SSDP scan for Roku devices failed", e)
+        }
+        return hosts
+    }
+
+    /** Extract the device host from an SSDP response's `LOCATION: http://<ip>:8060/` header. */
+    internal fun parseSsdpLocation(response: String): String? {
+        val location = response.lineSequence()
+            .firstOrNull { it.startsWith("LOCATION:", ignoreCase = true) }
+            ?.substringAfter(":")
+            ?.trim()
+            ?: return null
+        return try {
+            URI(location).host
+        } catch (e: Exception) {
+            null
+        }
+    }
+}
diff --git a/maestro-client/src/main/java/maestro/roku/RokuEcpClient.kt b/maestro-client/src/main/java/maestro/roku/RokuEcpClient.kt
new file mode 100644
index 0000000000..c05b19c6b6
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/roku/RokuEcpClient.kt
@@ -0,0 +1,585 @@
+package maestro.roku
+
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okio.Sink
+import okio.buffer
+import org.slf4j.LoggerFactory
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import org.w3c.dom.Node
+import java.io.ByteArrayInputStream
+import java.io.IOException
+import java.net.URLEncoder
+import java.security.MessageDigest
+import java.util.concurrent.TimeUnit
+import javax.xml.XMLConstants
+import javax.xml.parsers.DocumentBuilderFactory
+
+/**
+ * HTTP client for the Roku External Control Protocol (ECP). All Roku device
+ * communication goes through a REST API on device port 8060; screenshots go through
+ * the developer web server on port 80 (digest auth with the dev-mode password).
+ *
+ * Requires the device to be in developer mode with ECP network access set to
+ * "Permissive" (recent Roku OS versions return 403 on input commands otherwise).
+ *
+ * Reference: roku-test-automation ECP.ts / RokuDevice.ts.
+ */
+class RokuEcpClient(
+    val host: String,
+    val password: String = "",
+    private val ecpPort: Int = DEFAULT_ECP_PORT,
+    private val keypressDelayMs: Long = 100,
+    private val maxRetries: Int = 3,
+) {
+
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(10, TimeUnit.SECONDS)
+        .writeTimeout(10, TimeUnit.SECONDS)
+        .build()
+
+    private val digestLock = Any()
+    private var digestNonce: String? = null
+    private var digestNonceCount = 0
+
+    private val authClient = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .writeTimeout(10, TimeUnit.SECONDS)
+        .authenticator { _, response ->
+            if (response.request.header("Authorization") != null) {
+                null // Already tried auth, give up
+            } else {
+                buildDigestAuthRequest(response)
+            }
+        }
+        .build()
+
+    private val baseUrl get() = "http://$host:$ecpPort"
+
+    // --- Key Input ---
+
+    fun sendKeypress(key: String) {
+        ecpPost("keypress/${encodePathSegment(key)}")
+        if (keypressDelayMs > 0) {
+            Thread.sleep(keypressDelayMs)
+        }
+    }
+
+    fun sendKeyDown(key: String) {
+        ecpPost("keydown/${encodePathSegment(key)}")
+    }
+
+    fun sendKeyUp(key: String) {
+        ecpPost("keyup/${encodePathSegment(key)}")
+    }
+
+    /** Types text character-by-character via ECP `LIT_` keypresses. */
+    fun sendText(text: String) {
+        for (char in text) {
+            ecpPost("keypress/${encodePathSegment("LIT_$char")}")
+            if (keypressDelayMs > 0) {
+                Thread.sleep(keypressDelayMs)
+            }
+        }
+    }
+
+    // --- App Lifecycle ---
+
+    /**
+     * Launches a channel with the caller's parameters and nothing else. No
+     * `RTA_LAUNCH` flag: it asks a roku-test-automation channel not to restart, which
+     * is the opposite of the cold launch [maestro.drivers.RokuDriver.launchApp]
+     * guarantees by exiting to Home first — and on any other channel it is an
+     * unexpected parameter arriving alongside the deep link the flow asked for.
+     */
+    fun launchChannel(channelId: String, params: Map<String, String> = emptyMap()) {
+        val queryString = params.entries.joinToString("&") { (k, v) ->
+            "${URLEncoder.encode(k, "UTF-8")}=${URLEncoder.encode(v, "UTF-8")}"
+        }
+        val path = if (queryString.isEmpty()) "launch/$channelId" else "launch/$channelId?$queryString"
+        ecpPost(path)
+    }
+
+    fun getActiveApp(): ActiveApp? {
+        val doc = ecpGetXml("query/active-app") ?: return null
+        val root = doc.documentElement
+        val children = root.childNodes
+
+        for (i in 0 until children.length) {
+            val node = children.item(i)
+            if (node.nodeType == Node.ELEMENT_NODE && node.nodeName == "app") {
+                val element = node as Element
+                return ActiveApp(
+                    id = element.getAttribute("id"),
+                    title = element.textContent?.trim() ?: "",
+                    type = element.getAttribute("type"),
+                    version = element.getAttribute("version"),
+                )
+            }
+        }
+        return null
+    }
+
+    fun isActiveApp(channelId: String): Boolean {
+        return getActiveApp()?.id == channelId
+    }
+
+    // --- Device Info ---
+
+    fun getDeviceInfo(): RokuDeviceInfo? {
+        val doc = ecpGetXml("query/device-info") ?: return null
+        val root = doc.documentElement
+        val fields = mutableMapOf<String, String>()
+
+        val children = root.childNodes
+        for (i in 0 until children.length) {
+            val node = children.item(i)
+            if (node.nodeType == Node.ELEMENT_NODE) {
+                fields[node.nodeName] = node.textContent?.trim() ?: ""
+            }
+        }
+
+        return RokuDeviceInfo(
+            modelName = fields["model-name"] ?: "Unknown",
+            modelNumber = fields["model-number"] ?: "",
+            serialNumber = fields["serial-number"] ?: "",
+            softwareVersion = fields["software-version"] ?: "",
+            uiResolution = fields["ui-resolution"] ?: "1080p",
+            friendlyName = fields["friendly-device-name"] ?: fields["device-name"] ?: "",
+        )
+    }
+
+    // --- View Hierarchy ---
+
+    fun getAppUI(): Document? {
+        return ecpGetXml("query/app-ui")
+    }
+
+    fun getAppUIRaw(): String? {
+        val request = Request.Builder()
+            .url("$baseUrl/query/app-ui")
+            .get()
+            .build()
+
+        val response = try {
+            executeWithRetry(request)
+        } catch (e: IOException) {
+            logger.warn("ECP GET query/app-ui failed: {}", e.message)
+            return null
+        }
+
+        return try {
+            response.body?.string()
+        } catch (e: Exception) {
+            logger.warn("Failed to read app-ui response", e)
+            null
+        } finally {
+            response.close()
+        }
+    }
+
+    // --- Screenshot ---
+
+    /**
+     * Captures a screenshot from the Roku device. Two-step process:
+     * 1. POST /plugin_inspect to generate the screenshot (requires digest auth)
+     * 2. GET /pkgs/dev.jpg (or .png) to download it
+     *
+     * The dev server acknowledges the generation POST before the capture file is
+     * written (observed on Roku OS 14), so the download polls until the file's ETag
+     * differs from the pre-generation one; on timeout the current file is used (a
+     * re-capture of an unchanged screen can legitimately produce identical bytes).
+     *
+     * Reference: roku-test-automation RokuDevice.ts.
+     */
+    fun takeScreenshot(out: Sink) {
+        val previousEtags = SCREENSHOT_FORMATS.associateWith { screenshotEtag(it) }
+        generateScreenshot()
+
+        val deadline = System.currentTimeMillis() + SCREENSHOT_TIMEOUT_MS
+        while (true) {
+            val timedOut = System.currentTimeMillis() >= deadline
+            for (format in SCREENSHOT_FORMATS) {
+                // Cache-bust with a timestamp so no intermediary replays an old capture
+                val request = Request.Builder()
+                    .url("http://$host/pkgs/dev.$format?time=${System.currentTimeMillis()}")
+                    .get()
+                    .build()
+
+                try {
+                    authClient.newCall(request).execute().use { response ->
+                        if (response.isSuccessful) {
+                            val etag = response.header("ETag")
+                            val previous = previousEtags[format]
+                            val isFresh = previous == null || etag == null || etag != previous
+                            if (isFresh || timedOut) {
+                                if (!isFresh) {
+                                    logger.debug("Screenshot ETag unchanged after ${SCREENSHOT_TIMEOUT_MS}ms; using current capture")
+                                }
+                                response.body?.let { body ->
+                                    val bufferedOut = out.buffer()
+                                    bufferedOut.writeAll(body.source())
+                                    bufferedOut.flush()
+                                }
+                                return
+                            }
+                        }
+                    }
+                } catch (e: IOException) {
+                    logger.debug("Failed to download screenshot as $format", e)
+                }
+            }
+
+            if (timedOut) break
+            Thread.sleep(SCREENSHOT_POLL_INTERVAL_MS)
+        }
+
+        throw IOException(
+            "Failed to capture screenshot from Roku device at $host. " +
+                "Screenshots require the developer-mode password (MAESTRO_ROKU_PASSWORD)."
+        )
+    }
+
+    /** ETag of the current capture file, or null if none exists (or the server omits it). */
+    private fun screenshotEtag(format: String): String? {
+        val request = Request.Builder()
+            .url("http://$host/pkgs/dev.$format")
+            .head()
+            .build()
+        return try {
+            authClient.newCall(request).execute().use { response ->
+                if (response.isSuccessful) response.header("ETag") else null
+            }
+        } catch (e: IOException) {
+            null
+        }
+    }
+
+    private fun generateScreenshot() {
+        val url = "http://$host/plugin_inspect"
+
+        // The dev server only executes the form action when the multipart body arrives
+        // on an already-authorized request (curl's --digest behavior: an empty-body
+        // probe collects the challenge, then the form is sent with Authorization
+        // attached up front). Sending the body on the unauthenticated request and
+        // retrying via an OkHttp authenticator gets a 200 whose action silently never
+        // ran — so the handshake is done explicitly here.
+        val probe = Request.Builder()
+            .url(url)
+            .post("".toRequestBody(null))
+            .build()
+
+        val challenge = try {
+            client.newCall(probe).execute().use { response ->
+                if (response.code == 401) response.header("WWW-Authenticate") else null
+            }
+        } catch (e: IOException) {
+            throw IOException("Screenshot generation request to Roku device at $host failed", e)
+        }
+
+        // Multipart form matches the Roku dev web server's expected format. Two quirks,
+        // both verified against Roku OS 14 hardware: the empty `archive` field is
+        // required (without it the form handler silently does nothing), and parts must
+        // carry ONLY a Content-Disposition header — the server's parser ignores parts
+        // with a per-part Content-Length, which OkHttp's MultipartBody always adds.
+        // So the body is assembled by hand, curl-style.
+        val boundary = "----MaestroRokuFormBoundary${System.nanoTime()}"
+        val body = buildString {
+            append("--$boundary\r\n")
+            append("Content-Disposition: form-data; name=\"mysubmit\"\r\n\r\n")
+            append("Screenshot\r\n")
+            append("--$boundary\r\n")
+            append("Content-Disposition: form-data; name=\"archive\"\r\n\r\n")
+            append("\r\n")
+            append("--$boundary--\r\n")
+        }.toRequestBody("multipart/form-data; boundary=$boundary".toMediaType())
+
+        val request = Request.Builder()
+            .url(url)
+            .post(body)
+            .apply {
+                challenge
+                    ?.let { buildDigestHeader(it, "POST", "/plugin_inspect") }
+                    ?.let { header("Authorization", it) }
+            }
+            .build()
+
+        val responseBody = try {
+            client.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) {
+                    throw IOException(
+                        "Screenshot generation failed (HTTP ${response.code}). " +
+                            "Check the developer-mode password (MAESTRO_ROKU_PASSWORD)."
+                    )
+                }
+                response.body?.string() ?: ""
+            }
+        } catch (e: IOException) {
+            throw IOException("Screenshot generation request to Roku device at $host failed", e)
+        }
+
+        // The dev server reports the result inside the returned page (RTA pattern);
+        // anything else means no fresh capture was written to /pkgs/dev.jpg.
+        if (!responseBody.contains("Screenshot ok")) {
+            logger.debug("plugin_inspect did not confirm: {}", responseBody.replace("\n", " ").take(300))
+            throw IOException(
+                "Roku device at $host did not confirm the screenshot " +
+                    "(requires a sideloaded dev channel in the foreground)."
+            )
+        }
+    }
+
+    // --- Connectivity ---
+
+    fun isReachable(): Boolean {
+        return try {
+            val request = Request.Builder()
+                .url("$baseUrl/")
+                .get()
+                .build()
+            client.newCall(request).execute().close()
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    fun close() {
+        client.dispatcher.executorService.shutdown()
+        client.connectionPool.evictAll()
+        authClient.dispatcher.executorService.shutdown()
+        authClient.connectionPool.evictAll()
+    }
+
+    // --- Digest Auth ---
+
+    private fun buildDigestAuthRequest(response: Response): Request? {
+        val challengeHeader = response.header("WWW-Authenticate") ?: return null
+        val authValue = buildDigestHeader(
+            challengeHeader = challengeHeader,
+            method = response.request.method,
+            uri = response.request.url.encodedPath,
+        ) ?: return null
+
+        return response.request.newBuilder()
+            .header("Authorization", authValue)
+            .build()
+    }
+
+    /** RFC 2617: `nc` counts requests sent with one nonce, restarting at 1 for a new one. */
+    private fun nextNonceCount(nonce: String): Int = synchronized(digestLock) {
+        if (nonce != digestNonce) {
+            digestNonce = nonce
+            digestNonceCount = 0
+        }
+        ++digestNonceCount
+    }
+
+    private fun buildDigestHeader(challengeHeader: String, method: String, uri: String): String? {
+        if (!challengeHeader.startsWith("Digest ", ignoreCase = true)) return null
+
+        val params = parseDigestChallenge(challengeHeader.removePrefix("Digest ").removePrefix("digest "))
+        val realm = params["realm"] ?: return null
+        val nonce = params["nonce"] ?: return null
+        val qop = params["qop"]
+
+        val nc = String.format("%08x", nextNonceCount(nonce))
+        val cnonce = String.format("%08x", System.nanoTime())
+
+        val ha1 = md5Hex("$DEV_USERNAME:$realm:$password")
+        val ha2 = md5Hex("$method:$uri")
+
+        val digestResponse = if (qop != null) {
+            md5Hex("$ha1:$nonce:$nc:$cnonce:$qop:$ha2")
+        } else {
+            md5Hex("$ha1:$nonce:$ha2")
+        }
+
+        return buildString {
+            append("Digest username=\"$DEV_USERNAME\"")
+            append(", realm=\"$realm\"")
+            append(", nonce=\"$nonce\"")
+            append(", uri=\"$uri\"")
+            if (qop != null) {
+                append(", qop=$qop")
+                append(", nc=$nc")
+                append(", cnonce=\"$cnonce\"")
+            }
+            append(", response=\"$digestResponse\"")
+        }
+    }
+
+    // --- Internal HTTP helpers ---
+
+    /**
+     * Issues a state-changing ECP call (input, launch). Throws on failure: an ECP
+     * command that never reached the device must fail the flow rather than let it
+     * continue asserting against a screen no keypress ever touched.
+     */
+    private fun ecpPost(path: String) {
+        val request = Request.Builder()
+            .url("$baseUrl/$path")
+            .post("".toRequestBody("text/plain".toMediaType()))
+            .build()
+
+        executeWithRetry(request).close()
+    }
+
+    private fun ecpGetXml(path: String): Document? {
+        val request = Request.Builder()
+            .url("$baseUrl/$path")
+            .get()
+            .build()
+
+        // Queries stay tolerant: callers treat a null document as "hierarchy
+        // unavailable" and poll or report it themselves.
+        val response = try {
+            executeWithRetry(request)
+        } catch (e: IOException) {
+            logger.warn("ECP GET $path failed: {}", e.message)
+            return null
+        }
+
+        return try {
+            val bytes = response.body?.bytes() ?: return null
+            parseXml(bytes)
+        } catch (e: Exception) {
+            logger.warn("Failed to parse XML from $path", e)
+            null
+        } finally {
+            response.close()
+        }
+    }
+
+    /**
+     * Parses ECP XML. [DocumentBuilderFactory] is not thread-safe for
+     * `newDocumentBuilder()` and the driver polls the hierarchy from more than one
+     * thread, so the shared factory is only touched under a lock.
+     */
+    private fun parseXml(bytes: ByteArray): Document {
+        val builder = synchronized(documentBuilderFactory) { documentBuilderFactory.newDocumentBuilder() }
+        return builder.parse(ByteArrayInputStream(bytes))
+    }
+
+    /**
+     * Executes [request], retrying transport failures and 5xx responses. Throws
+     * [RokuEcpException] once the attempts are spent, carrying the HTTP status: OkHttp
+     * returns a [Response] for every status and only throws on transport failures, so a
+     * status the device rejected (403 when ECP access isn't Permissive) is the failure
+     * detail that matters most and must survive into the error.
+     */
+    private fun executeWithRetry(request: Request): Response {
+        var lastFailure: RokuEcpException? = null
+
+        for (attempt in 1..maxRetries) {
+            val failure = try {
+                val response = client.newCall(request).execute()
+                if (response.isSuccessful) {
+                    return response
+                }
+                val code = response.code
+                response.close()
+                RokuEcpException("ECP request to ${request.url} failed with HTTP $code.${hintFor(code)}", code)
+            } catch (e: IOException) {
+                RokuEcpException("ECP request to ${request.url} failed: ${e.message}", cause = e)
+            }
+
+            lastFailure = failure
+            // 4xx is the device's verdict on this request — a retry re-sends what it
+            // already rejected, so report it now instead of after three round trips.
+            val code = failure.statusCode
+            if (code != null && code in 400..499) break
+
+            if (attempt < maxRetries) {
+                logger.debug("{} (attempt {}/{}). Retrying.", failure.message, attempt, maxRetries)
+                Thread.sleep(RETRY_BACKOFF_MS)
+            }
+        }
+
+        throw lastFailure ?: RokuEcpException("ECP request to ${request.url} failed")
+    }
+
+    /** HTTP status the device answered with, or null for a transport failure. */
+    class RokuEcpException(
+        message: String,
+        val statusCode: Int? = null,
+        cause: Throwable? = null,
+    ) : IOException(message, cause)
+
+    data class ActiveApp(
+        val id: String,
+        val title: String,
+        val type: String,
+        val version: String,
+    )
+
+    data class RokuDeviceInfo(
+        val modelName: String,
+        val modelNumber: String,
+        val serialNumber: String,
+        val softwareVersion: String,
+        val uiResolution: String,
+        val friendlyName: String,
+    ) {
+        val widthPixels: Int get() = if (uiResolution.contains("1080")) 1920 else 1280
+        val heightPixels: Int get() = if (uiResolution.contains("1080")) 1080 else 720
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(RokuEcpClient::class.java)
+        // The XML is read off the network, so the parser takes no DTDs or external
+        // entities. Hardened once here; see parseXml for the locking.
+        private val documentBuilderFactory = DocumentBuilderFactory.newInstance().apply {
+            setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true)
+            setFeature("http://apache.org/xml/features/disallow-doctype-decl", true)
+            setFeature("http://xml.org/sax/features/external-general-entities", false)
+            setFeature("http://xml.org/sax/features/external-parameter-entities", false)
+            isXIncludeAware = false
+            isExpandEntityReferences = false
+        }
+
+        const val DEFAULT_ECP_PORT = 8060
+        private const val DEV_USERNAME = "rokudev"
+        private const val RETRY_BACKOFF_MS = 50L
+
+        /** Setup advice for the statuses a misconfigured device actually returns. */
+        internal fun hintFor(statusCode: Int): String = when (statusCode) {
+            403 -> " The device is refusing ECP commands: set Settings > System > Advanced system " +
+                "settings > Control by mobile apps > Network access to \"Permissive\"."
+            401 -> " Check the developer-mode password (MAESTRO_ROKU_PASSWORD)."
+            else -> ""
+        }
+
+        private val SCREENSHOT_FORMATS = listOf("jpg", "png")
+        private const val SCREENSHOT_TIMEOUT_MS = 10_000L
+        private const val SCREENSHOT_POLL_INTERVAL_MS = 250L
+
+        /** Percent-encode a URL path segment. URLEncoder alone form-encodes a space as
+         * `+`, which ECP would deliver as a literal plus (`LIT_+` types "+", not " "). */
+        internal fun encodePathSegment(value: String): String {
+            return URLEncoder.encode(value, "UTF-8").replace("+", "%20")
+        }
+
+        internal fun parseDigestChallenge(header: String): Map<String, String> {
+            val params = mutableMapOf<String, String>()
+            val regex = Regex("""(\w+)=(?:"([^"]*)"|([\w/]+))""")
+            for (match in regex.findAll(header)) {
+                val key = match.groupValues[1]
+                val value = match.groupValues[2].ifEmpty { match.groupValues[3] }
+                params[key] = value
+            }
+            return params
+        }
+
+        internal fun md5Hex(input: String): String {
+            val digest = MessageDigest.getInstance("MD5")
+            return digest.digest(input.toByteArray()).joinToString("") { "%02x".format(it) }
+        }
+    }
+}
diff --git a/maestro-client/src/main/java/maestro/roku/RokuKeyMapping.kt b/maestro-client/src/main/java/maestro/roku/RokuKeyMapping.kt
new file mode 100644
index 0000000000..ebe76c9f5d
--- /dev/null
+++ b/maestro-client/src/main/java/maestro/roku/RokuKeyMapping.kt
@@ -0,0 +1,58 @@
+package maestro.roku
+
+import maestro.KeyCode
+import maestro.SwipeDirection
+
+/**
+ * Maps Maestro [KeyCode] values to Roku ECP key strings.
+ * Based on the Roku External Control Protocol key names.
+ * Reference: roku-test-automation ECP.ts Key enum.
+ */
+object RokuKeyMapping {
+
+    private val mapping = mapOf(
+        KeyCode.REMOTE_UP to "Up",
+        KeyCode.REMOTE_DOWN to "Down",
+        KeyCode.REMOTE_LEFT to "Left",
+        KeyCode.REMOTE_RIGHT to "Right",
+        KeyCode.REMOTE_CENTER to "Select",
+        KeyCode.ENTER to "Select",
+        KeyCode.BACK to "Back",
+        KeyCode.ESCAPE to "Back",
+        KeyCode.BACKSPACE to "Backspace",
+        KeyCode.HOME to "Home",
+        KeyCode.REMOTE_PLAY_PAUSE to "Play",
+        KeyCode.REMOTE_FAST_FORWARD to "Fwd",
+        KeyCode.REMOTE_REWIND to "Rev",
+        KeyCode.REMOTE_STOP to "Play", // Roku uses Play as a toggle
+        KeyCode.REMOTE_NEXT to "Fwd",
+        KeyCode.REMOTE_PREVIOUS to "Rev",
+        KeyCode.REMOTE_MENU to "Info", // The * (options) button is Roku's menu
+        KeyCode.REMOTE_INFO to "Info",
+        KeyCode.REMOTE_REPLAY to "InstantReplay",
+        KeyCode.REMOTE_SEARCH to "Search",
+        KeyCode.POWER to "PowerOff",
+        KeyCode.VOLUME_UP to "VolumeUp",
+        KeyCode.VOLUME_DOWN to "VolumeDown",
+        KeyCode.REMOTE_BUTTON_A to "A",
+        KeyCode.REMOTE_BUTTON_B to "B",
+    )
+
+    fun toEcpKey(keyCode: KeyCode): String? = mapping[keyCode]
+
+    /**
+     * D-pad key for a swipe. A swipe drags the content, so it reveals what lies on the
+     * far side: swiping up brings up what is *below*, which on a focus-driven UI is a
+     * move down. Every direction therefore inverts. Matches the touch platforms, where
+     * `scrollVertical()` is `swipe(UP)` (`VegaDriver`), and web, where swiping up
+     * increases `scrollY`.
+     */
+    fun toEcpKey(swipeDirection: SwipeDirection): String = when (swipeDirection) {
+        SwipeDirection.UP -> "Down"
+        SwipeDirection.DOWN -> "Up"
+        SwipeDirection.LEFT -> "Right"
+        SwipeDirection.RIGHT -> "Left"
+    }
+
+    fun supportedKeyCodes(): Set<KeyCode> = mapping.keys
+}
diff --git a/maestro-client/src/test/java/maestro/roku/RokuAppUIParserTest.kt b/maestro-client/src/test/java/maestro/roku/RokuAppUIParserTest.kt
new file mode 100644
index 0000000000..02e79ff980
--- /dev/null
+++ b/maestro-client/src/test/java/maestro/roku/RokuAppUIParserTest.kt
@@ -0,0 +1,150 @@
+package maestro.roku
+
+import com.google.common.truth.Truth.assertThat
+import maestro.TreeNode
+import org.junit.jupiter.api.Test
+import java.io.ByteArrayInputStream
+import javax.xml.parsers.DocumentBuilderFactory
+
+internal class RokuAppUIParserTest {
+
+    // Mirrors the ECP /query/app-ui shape: topscreen > screen > RenderableNode tree,
+    // curly-brace bounds/translation arrays, `name` node ids, RowListItem's trailing
+    // duplicate Group (the RTA pattern the parser must drop).
+    private val appUi = """
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <app-ui>
+          <status>OK</status>
+          <topscreen>
+            <plugin id="dev" name="Maestro Roku Demo"/>
+            <screen focused="true" type="screen">
+              <RenderableNode name="rootGroup" subtype="Group" bounds="{0, 0, 1920, 1080}">
+                <Label name="titleLabel" text="Roku Demo" bounds="{100, 50, 400, 60}" color="#FFFFFFFF"/>
+                <RenderableNode name="menu" subtype="Group" translation="{100, 200}" bounds="{100, 200, 400, 400}">
+                  <Button name="button-one" text="Button One" focusable="true" focused="true" bounds="{0, 0, 400, 100}"/>
+                  <Button name="button-two" text="Button Two" focusable="true" focused="false" bounds="{0, 120, 400, 100}"/>
+                  <Label name="hiddenLabel" text="Hidden" visible="false" bounds="{0, 240, 400, 100}"/>
+                  <Label name="fadedLabel" text="Faded" opacity="0" bounds="{0, 360, 400, 100}"/>
+                </RenderableNode>
+                <RenderableNode name="hiddenKeyboard" subtype="Group" visible="false" bounds="{0, 900, 1920, 180}">
+                  <Button name="keyboard-key-a" text="A" focusable="true" bounds="{0, 0, 100, 100}"/>
+                </RenderableNode>
+                <RenderableNode name="hero" subtype="LayoutGroup" bounds="{0, 480, 1920, 100}"/>
+                <Label name="truncatedBounds" text="Truncated" bounds="{40}" translation="{80}"/>
+                <RowListItem name="row0" bounds="{0, 600, 1920, 300}">
+                  <MarkupGrid name="grid0" bounds="{60, 0, 1800, 300}">
+                    <Poster name="poster0" uri="pkg:/images/poster.png" bounds="{0, 0, 300, 300}"/>
+                  </MarkupGrid>
+                  <RenderableNode name="rtaDuplicate" subtype="Group" bounds="{0, 0, 1920, 300}"/>
+                </RowListItem>
+              </RenderableNode>
+            </screen>
+          </topscreen>
+        </app-ui>
+    """.trimIndent()
+
+    private fun parse(xml: String = appUi): TreeNode {
+        val document = DocumentBuilderFactory.newInstance()
+            .newDocumentBuilder()
+            .parse(ByteArrayInputStream(xml.toByteArray()))
+        return RokuAppUIParser.parse(document)
+    }
+
+    private fun TreeNode.byId(id: String): TreeNode? =
+        aggregate().find { it.attributes["resource-id"] == id }
+
+    @Test
+    fun `root is a full-screen Roku Screen node`() {
+        val root = parse()
+        assertThat(root.attributes["text"]).isEqualTo("Roku Screen")
+        assertThat(root.attributes["bounds"]).isEqualTo("[0,0][1920,1080]")
+        assertThat(root.focused).isTrue()
+    }
+
+    @Test
+    fun `honors an explicit design resolution`() {
+        val document = DocumentBuilderFactory.newInstance()
+            .newDocumentBuilder()
+            .parse(ByteArrayInputStream(appUi.toByteArray()))
+        val root = RokuAppUIParser.parse(document, screenWidth = 1280, screenHeight = 720)
+        assertThat(root.attributes["bounds"]).isEqualTo("[0,0][1280,720]")
+    }
+
+    @Test
+    fun `surfaces node ids, text and scene-absolute bounds`() {
+        val root = parse()
+
+        val title = root.byId("titleLabel")
+        assertThat(title).isNotNull()
+        assertThat(title!!.attributes["text"]).isEqualTo("Roku Demo")
+        assertThat(title.attributes["bounds"]).isEqualTo("[100,50][500,110]")
+        assertThat(title.attributes["color"]).isEqualTo("#FFFFFFFF")
+
+        // Children accumulate the parent's translation offset
+        val buttonTwo = root.byId("button-two")
+        assertThat(buttonTwo).isNotNull()
+        assertThat(buttonTwo!!.attributes["bounds"]).isEqualTo("[100,320][500,420]")
+    }
+
+    @Test
+    fun `maps focusable and focused state`() {
+        val root = parse()
+
+        val focused = root.byId("button-one")!!
+        assertThat(focused.clickable).isTrue()
+        assertThat(focused.focused).isTrue()
+        assertThat(focused.selected).isTrue()
+
+        val unfocused = root.byId("button-two")!!
+        assertThat(unfocused.clickable).isTrue()
+        assertThat(unfocused.focused).isFalse()
+    }
+
+    // ViewHierarchy.isVisible only consults bounds, so an unrendered node left in the
+    // tree would satisfy assertVisible and break assertNotVisible.
+    @Test
+    fun `nodes the device is not rendering are dropped`() {
+        val root = parse()
+        assertThat(root.byId("hiddenLabel")).isNull()
+        assertThat(root.byId("fadedLabel")).isNull()
+    }
+
+    @Test
+    fun `an invisible node takes its subtree with it`() {
+        val root = parse()
+        assertThat(root.byId("hiddenKeyboard")).isNull()
+        assertThat(root.byId("keyboard-key-a")).isNull()
+    }
+
+    @Test
+    fun `reports the SceneGraph subtype the device sent`() {
+        val root = parse()
+        // The attribute wins over the element name, which says nothing for a
+        // generic RenderableNode...
+        assertThat(root.byId("hero")!!.attributes["subtype"]).isEqualTo("LayoutGroup")
+        // ...and the element name is the fallback when there is no attribute.
+        assertThat(root.byId("titleLabel")!!.attributes["subtype"]).isEqualTo("Label")
+    }
+
+    // A short array is unusable, and callers index it positionally.
+    @Test
+    fun `a truncated bounds or translation array is ignored, not indexed`() {
+        val node = parse().byId("truncatedBounds")
+        assertThat(node).isNotNull()
+        assertThat(node!!.attributes).doesNotContainKey("bounds")
+    }
+
+    @Test
+    fun `drops the trailing duplicate group under RowListItem`() {
+        val root = parse()
+        assertThat(root.byId("rtaDuplicate")).isNull()
+        assertThat(root.byId("poster0")).isNotNull()
+    }
+
+    @Test
+    fun `missing screen yields an empty placeholder tree`() {
+        val root = parse("<app-ui><status>OK</status></app-ui>")
+        assertThat(root.attributes["text"]).isEqualTo("Roku App UI")
+        assertThat(root.children).isEmpty()
+    }
+}
diff --git a/maestro-client/src/test/java/maestro/roku/RokuDeviceDiscoveryTest.kt b/maestro-client/src/test/java/maestro/roku/RokuDeviceDiscoveryTest.kt
new file mode 100644
index 0000000000..844afcf5d4
--- /dev/null
+++ b/maestro-client/src/test/java/maestro/roku/RokuDeviceDiscoveryTest.kt
@@ -0,0 +1,29 @@
+package maestro.roku
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+internal class RokuDeviceDiscoveryTest {
+
+    // Real SSDP M-SEARCH response shape for `ST: roku:ecp`.
+    @Test
+    fun `parses the device host from an SSDP response`() {
+        val response = listOf(
+            "HTTP/1.1 200 OK",
+            "Cache-Control: max-age=3600",
+            "ST: roku:ecp",
+            "Location: http://192.168.1.114:8060/",
+            "USN: uuid:roku:ecp:X00000AB12CD",
+            "",
+            "",
+        ).joinToString("\r\n")
+
+        assertThat(RokuDeviceDiscovery.parseSsdpLocation(response)).isEqualTo("192.168.1.114")
+    }
+
+    @Test
+    fun `returns null when the response has no location header`() {
+        val response = "HTTP/1.1 200 OK\r\nST: roku:ecp\r\n\r\n"
+        assertThat(RokuDeviceDiscovery.parseSsdpLocation(response)).isNull()
+    }
+}
diff --git a/maestro-client/src/test/java/maestro/roku/RokuEcpClientTest.kt b/maestro-client/src/test/java/maestro/roku/RokuEcpClientTest.kt
new file mode 100644
index 0000000000..6fa053dc21
--- /dev/null
+++ b/maestro-client/src/test/java/maestro/roku/RokuEcpClientTest.kt
@@ -0,0 +1,169 @@
+package maestro.roku
+
+import com.google.common.truth.Truth.assertThat
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+internal class RokuEcpClientTest {
+
+    private fun withServer(block: (MockWebServer, RokuEcpClient) -> Unit) {
+        val server = MockWebServer()
+        server.start()
+        val client = RokuEcpClient(
+            host = server.hostName,
+            ecpPort = server.port,
+            keypressDelayMs = 0,
+        )
+        try {
+            block(server, client)
+        } finally {
+            client.close()
+            server.shutdown()
+        }
+    }
+
+    // The failure mode this guards: recent Roku OS answers input commands with 403 when
+    // ECP access isn't Permissive while /query/app-ui keeps working, so a swallowed POST
+    // means the hierarchy reads fine, every keypress no-ops, and the flow passes green.
+    @Test
+    fun `a rejected input command fails instead of warning`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(403))
+
+            val error = assertThrows<RokuEcpClient.RokuEcpException> { client.sendKeypress("Select") }
+
+            assertThat(error.statusCode).isEqualTo(403)
+            assertThat(error).hasMessageThat().contains("403")
+            assertThat(error).hasMessageThat().contains("Permissive")
+        }
+    }
+
+    // OkHttp only throws on transport failures, so a status has to be read off the
+    // response — retrying a 4xx just re-sends what the device already rejected.
+    @Test
+    fun `a 4xx is reported without retrying`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(404))
+
+            assertThrows<RokuEcpClient.RokuEcpException> { client.sendKeypress("Down") }
+
+            assertThat(server.requestCount).isEqualTo(1)
+        }
+    }
+
+    @Test
+    fun `a 5xx is retried and the final status is reported`() {
+        withServer { server, client ->
+            repeat(3) { server.enqueue(MockResponse().setResponseCode(503)) }
+
+            val error = assertThrows<RokuEcpClient.RokuEcpException> { client.sendKeypress("Down") }
+
+            assertThat(error.statusCode).isEqualTo(503)
+            assertThat(server.requestCount).isEqualTo(3)
+        }
+    }
+
+    @Test
+    fun `a transient failure is retried and then succeeds`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(500))
+            server.enqueue(MockResponse().setResponseCode(200))
+
+            client.sendKeypress("Up")
+
+            assertThat(server.requestCount).isEqualTo(2)
+        }
+    }
+
+    // No RTA_LAUNCH: it asks an RTA channel not to restart, which contradicts the cold
+    // launch the driver guarantees, and it rides along on every deep link.
+    @Test
+    fun `launch sends only the parameters it was given`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(200))
+
+            client.launchChannel("dev", mapOf("contentId" to "abc123"))
+
+            assertThat(server.takeRequest().path).isEqualTo("/launch/dev?contentId=abc123")
+        }
+    }
+
+    @Test
+    fun `a launch with no parameters sends no query string`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(200))
+
+            client.launchChannel("dev")
+
+            assertThat(server.takeRequest().path).isEqualTo("/launch/dev")
+        }
+    }
+
+    @Test
+    fun `parses a well-formed query response`() {
+        withServer { server, client ->
+            server.enqueue(
+                MockResponse().setBody(
+                    """<active-app><app id="dev" type="appl" version="1.0">Maestro Roku Demo</app></active-app>"""
+                )
+            )
+
+            val app = client.getActiveApp()
+
+            assertThat(app?.id).isEqualTo("dev")
+            assertThat(app?.title).isEqualTo("Maestro Roku Demo")
+        }
+    }
+
+    // The XML comes off the network, so the parser must refuse doctypes outright.
+    @Test
+    fun `a query response declaring a doctype is rejected`() {
+        withServer { server, client ->
+            server.enqueue(
+                MockResponse().setBody(
+                    """
+                    <?xml version="1.0"?>
+                    <!DOCTYPE active-app [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>
+                    <active-app><app id="dev">&xxe;</app></active-app>
+                    """.trimIndent()
+                )
+            )
+
+            assertThat(client.getActiveApp()).isNull()
+        }
+    }
+
+    // Queries stay tolerant: callers poll them and report an unavailable hierarchy
+    // themselves, so a failed read is null rather than a thrown flow failure.
+    @Test
+    fun `a failed query returns null`() {
+        withServer { server, client ->
+            server.enqueue(MockResponse().setResponseCode(403))
+
+            assertThat(client.getActiveApp()).isNull()
+        }
+    }
+
+    // ECP delivers path segments literally: a form-encoded "+" would type a plus
+    // sign, so spaces must be percent-encoded.
+    @Test
+    fun `encodes literal keypress path segments with percent-encoded spaces`() {
+        assertThat(RokuEcpClient.encodePathSegment("LIT_ ")).isEqualTo("LIT_%20")
+        assertThat(RokuEcpClient.encodePathSegment("LIT_a")).isEqualTo("LIT_a")
+        assertThat(RokuEcpClient.encodePathSegment("LIT_&")).isEqualTo("LIT_%26")
+        assertThat(RokuEcpClient.encodePathSegment("LIT_+")).isEqualTo("LIT_%2B")
+    }
+
+    // Real challenge shape from the Roku dev web server (Roku OS 14).
+    @Test
+    fun `parses the dev server digest challenge`() {
+        val params = RokuEcpClient.parseDigestChallenge(
+            """qop="auth", realm="rokudev", nonce="1787436926""""
+        )
+        assertThat(params["qop"]).isEqualTo("auth")
+        assertThat(params["realm"]).isEqualTo("rokudev")
+        assertThat(params["nonce"]).isEqualTo("1787436926")
+    }
+}
diff --git a/maestro-client/src/test/java/maestro/roku/RokuKeyMappingTest.kt b/maestro-client/src/test/java/maestro/roku/RokuKeyMappingTest.kt
new file mode 100644
index 0000000000..2937c59d57
--- /dev/null
+++ b/maestro-client/src/test/java/maestro/roku/RokuKeyMappingTest.kt
@@ -0,0 +1,46 @@
+package maestro.roku
+
+import com.google.common.truth.Truth.assertThat
+import maestro.KeyCode
+import maestro.SwipeDirection
+import org.junit.jupiter.api.Test
+
+internal class RokuKeyMappingTest {
+
+    @Test
+    fun `maps the D-pad and activation keys`() {
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_UP)).isEqualTo("Up")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_DOWN)).isEqualTo("Down")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_LEFT)).isEqualTo("Left")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_RIGHT)).isEqualTo("Right")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_CENTER)).isEqualTo("Select")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.ENTER)).isEqualTo("Select")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.BACK)).isEqualTo("Back")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.HOME)).isEqualTo("Home")
+    }
+
+    @Test
+    fun `maps the Roku-specific remote keys`() {
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_INFO)).isEqualTo("Info")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_REPLAY)).isEqualTo("InstantReplay")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_SEARCH)).isEqualTo("Search")
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.REMOTE_MENU)).isEqualTo("Info")
+    }
+
+    // A swipe reveals what lies on the far side of the drag, so on a focus-driven UI
+    // every direction inverts — matching Vega, where scrollVertical() is swipe(UP).
+    @Test
+    fun `swipe directions invert into D-pad keys`() {
+        assertThat(RokuKeyMapping.toEcpKey(SwipeDirection.UP)).isEqualTo("Down")
+        assertThat(RokuKeyMapping.toEcpKey(SwipeDirection.DOWN)).isEqualTo("Up")
+        assertThat(RokuKeyMapping.toEcpKey(SwipeDirection.LEFT)).isEqualTo("Right")
+        assertThat(RokuKeyMapping.toEcpKey(SwipeDirection.RIGHT)).isEqualTo("Left")
+    }
+
+    @Test
+    fun `unsupported keys return null`() {
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.TAB)).isNull()
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.TV_INPUT)).isNull()
+        assertThat(RokuKeyMapping.toEcpKey(KeyCode.LOCK)).isNull()
+    }
+}
diff --git a/maestro-orchestra/src/main/java/maestro/orchestra/validation/AppValidator.kt b/maestro-orchestra/src/main/java/maestro/orchestra/validation/AppValidator.kt
index bc203f8fd8..c22ff84758 100644
--- a/maestro-orchestra/src/main/java/maestro/orchestra/validation/AppValidator.kt
+++ b/maestro-orchestra/src/main/java/maestro/orchestra/validation/AppValidator.kt
@@ -87,6 +87,7 @@ class AppValidator(
             Platform.ANDROID -> return
             Platform.TVOS -> return
             Platform.VEGA -> return
+            Platform.ROKU -> return
             Platform.WEB -> return
         }
     }
diff --git a/maestro-studio/web/src/context/DeviceContext.tsx b/maestro-studio/web/src/context/DeviceContext.tsx
index 5df5014412..fa6a0d9e23 100644
--- a/maestro-studio/web/src/context/DeviceContext.tsx
+++ b/maestro-studio/web/src/context/DeviceContext.tsx
@@ -85,15 +85,15 @@ export const DeviceProvider: React.FC<DeviceProviderProps> = ({
   }, [deviceScreenState, error, isLoading]);
 
   /**
-   * Default "TV mode" (D-pad navigation) from the device platform: on for tvOS,
-   * off otherwise. Re-derived only when the platform changes, so a manual toggle
-   * survives screen refreshes. Web/canvas TV apps can enable it by hand.
+   * Default "TV mode" (D-pad navigation) from the device platform: on for tvOS and
+   * Roku, off otherwise. Re-derived only when the platform changes, so a manual
+   * toggle survives screen refreshes. Web/canvas TV apps can enable it by hand.
    */
   useEffect(() => {
     const platform = deviceScreenState?.platform?.toUpperCase();
     if (platform && platform !== prevPlatformRef.current) {
       prevPlatformRef.current = platform;
-      setTvMode(platform === "TVOS");
+      setTvMode(platform === "TVOS" || platform === "ROKU");
     }
   }, [deviceScreenState?.platform]);