agent-device 0.14.8 → 0.14.9

package/dist/src/selectors.d.ts

@@ -35,6 +35,7 @@ declare type RawSnapshotNode = {
     rect?: Rect;
     enabled?: boolean;
     selected?: boolean;
+    focused?: boolean;
     hittable?: boolean;
     depth?: number;
     parentIndex?: number;

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift

@@ -13,6 +13,18 @@ extension RunnerTests {
     return (gestureStartUptimeMs, currentUptimeMs())
   }
 
+  private func unsupportedResponse(for outcome: RunnerInteractionOutcome) -> Response? {
+    switch outcome {
+    case .performed:
+      return nil
+    case .unsupported(let message):
+      return Response(
+        ok: false,
+        error: ErrorPayload(code: "UNSUPPORTED_OPERATION", message: message)
+      )
+    }
+  }
+
   func execute(command: Command) throws -> Response {
     if Thread.isMainThread {
       return try executeOnMainSafely(command: command)
@@ -231,11 +243,15 @@ extension RunnerTests {
     case .tap:
       if let text = command.text {
         if let element = findElement(app: activeApp, text: text) {
+          var outcome = RunnerInteractionOutcome.performed
           let timing = measureGesture {
             withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
-              element.tap()
+              outcome = activateElement(app: activeApp, element: element, action: "tap by text")
             }
           }
+          if let response = unsupportedResponse(for: outcome) {
+            return response
+          }
           return Response(
             ok: true,
             data: DataPayload(
@@ -249,11 +265,15 @@ extension RunnerTests {
       }
       if let x = command.x, let y = command.y {
         let touchFrame = resolvedTouchVisualizationFrame(app: activeApp, x: x, y: y)
+        var outcome = RunnerInteractionOutcome.performed
         let timing = measureGesture {
           withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
-            tapAt(app: activeApp, x: x, y: y)
+            outcome = tapAt(app: activeApp, x: x, y: y)
           }
         }
+        if let response = unsupportedResponse(for: outcome) {
+          return response
+        }
         return Response(
           ok: true,
           data: DataPayload(
@@ -309,13 +329,19 @@ extension RunnerTests {
       let doubleTap = command.doubleTap ?? false
       let touchFrame = resolvedTouchVisualizationFrame(app: activeApp, x: x, y: y)
       if doubleTap {
+        var outcome = RunnerInteractionOutcome.performed
         let timing = measureGesture {
           withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
             runSeries(count: count, pauseMs: intervalMs) { _ in
-              doubleTapAt(app: activeApp, x: x, y: y)
+              if case .performed = outcome {
+                outcome = doubleTapAt(app: activeApp, x: x, y: y)
+              }
             }
           }
         }
+        if let response = unsupportedResponse(for: outcome) {
+          return response
+        }
         return Response(
           ok: true,
           data: DataPayload(
@@ -329,13 +355,19 @@ extension RunnerTests {
           )
         )
       }
+      var outcome = RunnerInteractionOutcome.performed
       let timing = measureGesture {
         withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
           runSeries(count: count, pauseMs: intervalMs) { _ in
-            tapAt(app: activeApp, x: x, y: y)
+            if case .performed = outcome {
+              outcome = tapAt(app: activeApp, x: x, y: y)
+            }
           }
         }
       }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
       return Response(
         ok: true,
         data: DataPayload(
@@ -354,11 +386,15 @@ extension RunnerTests {
       }
       let duration = (command.durationMs ?? 800) / 1000.0
       let touchFrame = resolvedTouchVisualizationFrame(app: activeApp, x: x, y: y)
+      var outcome = RunnerInteractionOutcome.performed
       let timing = measureGesture {
         withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
-          longPressAt(app: activeApp, x: x, y: y, duration: duration)
+          outcome = longPressAt(app: activeApp, x: x, y: y, duration: duration)
         }
       }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
       return Response(
         ok: true,
         data: DataPayload(
@@ -377,11 +413,15 @@ extension RunnerTests {
       }
       let holdDuration = min(max((command.durationMs ?? 60) / 1000.0, 0.016), 10.0)
       let dragFrame = resolvedDragVisualizationFrame(app: activeApp, x: x, y: y, x2: x2, y2: y2)
+      var outcome = RunnerInteractionOutcome.performed
       let timing = measureGesture {
         withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
-          dragAt(app: activeApp, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
+          outcome = dragAt(app: activeApp, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
         }
       }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
       return Response(
         ok: true,
         data: DataPayload(
@@ -407,18 +447,25 @@ extension RunnerTests {
         return Response(ok: false, error: ErrorPayload(message: "dragSeries pattern must be one-way or ping-pong"))
       }
       let holdDuration = min(max((command.durationMs ?? 60) / 1000.0, 0.016), 10.0)
+      var outcome = RunnerInteractionOutcome.performed
       let timing = measureGesture {
         withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
           runSeries(count: count, pauseMs: pauseMs) { idx in
+            guard case .performed = outcome else {
+              return
+            }
             let reverse = pattern == "ping-pong" && (idx % 2 == 1)
             if reverse {
-              dragAt(app: activeApp, x: x2, y: y2, x2: x, y2: y, holdDuration: holdDuration)
+              outcome = dragAt(app: activeApp, x: x2, y: y2, x2: x, y2: y, holdDuration: holdDuration)
             } else {
-              dragAt(app: activeApp, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
+              outcome = dragAt(app: activeApp, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
             }
           }
         }
       }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
+      }
       return Response(
         ok: true,
         data: DataPayload(
@@ -427,6 +474,18 @@ extension RunnerTests {
           gestureEndUptimeMs: timing.gestureEndUptimeMs
         )
       )
+    case .remotePress:
+      guard let button = tvRemoteButton(from: command.remoteButton) else {
+        return Response(ok: false, error: ErrorPayload(message: "remotePress requires remoteButton"))
+      }
+      let duration = (command.durationMs ?? 0) / 1000.0
+      guard pressTvRemote(button, duration: duration) else {
+        return Response(
+          ok: false,
+          error: ErrorPayload(code: "UNSUPPORTED_OPERATION", message: "remotePress is only supported on tvOS")
+        )
+      }
+      return Response(ok: true, data: DataPayload(message: "remote pressed"))
     case .type:
       guard let text = command.text else {
         return Response(ok: false, error: ErrorPayload(message: "type requires text"))
@@ -633,13 +692,23 @@ extension RunnerTests {
         return Response(ok: false, error: ErrorPayload(message: "alert not found"))
       }
       if action == "accept" {
-        let button = alert.buttons.allElementsBoundByIndex.first
-        button?.tap()
+        guard let button = alert.buttons.allElementsBoundByIndex.first else {
+          return Response(ok: false, error: ErrorPayload(message: "alert accept button not found"))
+        }
+        let outcome = activateElement(app: activeApp, element: button, action: "alert accept")
+        if let response = unsupportedResponse(for: outcome) {
+          return response
+        }
         return Response(ok: true, data: DataPayload(message: "accepted"))
       }
       if action == "dismiss" {
-        let button = alert.buttons.allElementsBoundByIndex.last
-        button?.tap()
+        guard let button = alert.buttons.allElementsBoundByIndex.last else {
+          return Response(ok: false, error: ErrorPayload(message: "alert dismiss button not found"))
+        }
+        let outcome = activateElement(app: activeApp, element: button, action: "alert dismiss")
+        if let response = unsupportedResponse(for: outcome) {
+          return response
+        }
         return Response(ok: true, data: DataPayload(message: "dismissed"))
       }
       let buttonLabels = alert.buttons.allElementsBoundByIndex.map { $0.label }
@@ -648,8 +717,12 @@ extension RunnerTests {
       guard let scale = command.scale, scale > 0 else {
         return Response(ok: false, error: ErrorPayload(message: "pinch requires scale > 0"))
       }
+      var outcome = RunnerInteractionOutcome.performed
       let timing = measureGesture {
-        pinch(app: activeApp, scale: scale, x: command.x, y: command.y)
+        outcome = pinch(app: activeApp, scale: scale, x: command.x, y: command.y)
+      }
+      if let response = unsupportedResponse(for: outcome) {
+        return response
       }
       return Response(
         ok: true,

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Interaction.swift

@@ -26,6 +26,9 @@ extension RunnerTests {
       return true
     }
     return false
+#elseif os(tvOS)
+    _ = pressTvRemote(.menu)
+    return true
 #else
     let buttons = app.navigationBars.buttons.allElementsBoundByIndex
     if let back = buttons.first(where: { $0.isHittable }) {
@@ -37,20 +40,26 @@ extension RunnerTests {
   }
 
   func performBackGesture(app: XCUIApplication) {
-    if pressTvRemoteMenuIfAvailable() {
+    if pressTvRemote(.menu) {
       return
     }
+    performCoordinateBackGesture(app: app)
+  }
+
+  private func performCoordinateBackGesture(app: XCUIApplication) {
+#if !os(tvOS)
     let target = app.windows.firstMatch.exists ? app.windows.firstMatch : app
     let start = target.coordinate(withNormalizedOffset: CGVector(dx: 0.05, dy: 0.5))
     let end = target.coordinate(withNormalizedOffset: CGVector(dx: 0.8, dy: 0.5))
     start.press(forDuration: 0.05, thenDragTo: end)
+#endif
   }
 
   func performSystemBackAction(app: XCUIApplication) -> Bool {
 #if os(macOS)
     return false
 #else
-    if pressTvRemoteMenuIfAvailable() {
+    if pressTvRemote(.menu) {
       return true
     }
     performBackGesture(app: app)
@@ -59,20 +68,28 @@ extension RunnerTests {
   }
 
   func performAppSwitcherGesture(app: XCUIApplication) {
-    if performTvRemoteAppSwitcherIfAvailable() {
+    if pressTvRemote(.home) {
+      sleepFor(resolveTvRemoteDoublePressDelay())
+      _ = pressTvRemote(.home)
       return
     }
+    performCoordinateAppSwitcherGesture(app: app)
+  }
+
+  private func performCoordinateAppSwitcherGesture(app: XCUIApplication) {
+#if !os(tvOS)
     let target = app.windows.firstMatch.exists ? app.windows.firstMatch : app
     let start = target.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.99))
     let end = target.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.7))
     start.press(forDuration: 0.6, thenDragTo: end)
+#endif
   }
 
   func pressHomeButton() {
 #if os(macOS)
     return
 #else
-    if pressTvRemoteHomeIfAvailable() {
+    if pressTvRemote(.home) {
       return
     }
     XCUIDevice.shared.press(.home)
@@ -80,7 +97,7 @@ extension RunnerTests {
   }
 
   func rotateDevice(to orientationName: String) -> Bool {
-#if os(macOS)
+#if os(macOS) || os(tvOS)
     return false
 #else
     switch orientationName {
@@ -100,48 +117,6 @@ extension RunnerTests {
 #endif
   }
 
-  private func pressTvRemoteMenuIfAvailable() -> Bool {
-#if os(tvOS)
-    XCUIRemote.shared.press(.menu)
-    return true
-#else
-    return false
-#endif
-  }
-
-  private func pressTvRemoteHomeIfAvailable() -> Bool {
-#if os(tvOS)
-    XCUIRemote.shared.press(.home)
-    return true
-#else
-    return false
-#endif
-  }
-
-  private func performTvRemoteAppSwitcherIfAvailable() -> Bool {
-#if os(tvOS)
-    XCUIRemote.shared.press(.home)
-    sleepFor(resolveTvRemoteDoublePressDelay())
-    XCUIRemote.shared.press(.home)
-    return true
-#else
-    return false
-#endif
-  }
-
-  private func resolveTvRemoteDoublePressDelay() -> TimeInterval {
-    guard
-      let raw = ProcessInfo.processInfo.environment["AGENT_DEVICE_TV_REMOTE_DOUBLE_PRESS_DELAY_MS"],
-      !raw.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-    else {
-      return tvRemoteDoublePressDelayDefault
-    }
-    guard let parsedMs = Double(raw), parsedMs >= 0 else {
-      return tvRemoteDoublePressDelayDefault
-    }
-    return min(parsedMs, 1000) / 1000.0
-  }
-
   func findElement(app: XCUIApplication, text: String) -> XCUIElement? {
     let predicate = NSPredicate(format: "label CONTAINS[c] %@ OR identifier CONTAINS[c] %@ OR value CONTAINS[c] %@", text, text, text)
     let element = app.descendants(matching: .any).matching(predicate).firstMatch
@@ -183,7 +158,9 @@ extension RunnerTests {
   }
 
   func clearTextInput(_ element: XCUIElement) {
+#if !os(tvOS)
     moveCaretToEnd(element: element)
+#endif
     let count = estimatedDeleteCount(for: element)
     let deletes = String(repeating: XCUIKeyboardKey.delete.rawValue, count: count)
     element.typeText(deletes)
@@ -268,6 +245,12 @@ extension RunnerTests {
       return (wasVisible: false, dismissed: false, visible: false)
     }
 
+#if os(tvOS)
+    _ = pressTvRemote(.menu)
+    sleepFor(0.2)
+    let visible = isKeyboardVisible(app: app)
+    return (wasVisible: true, dismissed: !visible, visible: visible)
+#else
     let keyboard = app.keyboards.firstMatch
     keyboard.swipeDown()
     sleepFor(0.2)
@@ -282,9 +265,13 @@ extension RunnerTests {
     }
 
     return (wasVisible: true, dismissed: false, visible: isKeyboardVisible(app: app))
+#endif
   }
 
   private func tapKeyboardDismissControl(app: XCUIApplication) -> Bool {
+#if os(tvOS)
+    return false
+#else
     let keyboardFrame = app.keyboards.firstMatch.frame
     for label in ["Hide keyboard", "Dismiss keyboard", "Done"] {
       let candidates = [
@@ -313,6 +300,7 @@ extension RunnerTests {
       }
     }
     return false
+#endif
   }
 
   private func isKeyboardAccessoryControl(_ element: XCUIElement, keyboardFrame: CGRect) -> Bool {
@@ -324,6 +312,9 @@ extension RunnerTests {
   }
 
   private func moveCaretToEnd(element: XCUIElement) {
+#if os(tvOS)
+    return
+#else
     let frame = element.frame
     guard !frame.isEmpty else {
       element.tap()
@@ -334,6 +325,7 @@ extension RunnerTests {
       CGVector(dx: max(2, frame.width - 4), dy: max(2, frame.height / 2))
     )
     target.tap()
+#endif
   }
 
   private func estimatedDeleteCount(for element: XCUIElement) -> Int {
@@ -379,49 +371,64 @@ extension RunnerTests {
     return element.exists ? element : nil
   }
 
-  func tapAt(app: XCUIApplication, x: Double, y: Double) {
-    let coordinate = interactionCoordinate(app: app, x: x, y: y)
-    coordinate.tap()
+  func tapAt(app: XCUIApplication, x: Double, y: Double) -> RunnerInteractionOutcome {
+    if let outcome = selectFocusedTvElement(app: app, point: CGPoint(x: x, y: y), action: "tap") {
+      return outcome
+    }
+    return performCoordinateTap(app: app, x: x, y: y)
   }
 
   func mouseClickAt(app: XCUIApplication, x: Double, y: Double, button: String) throws {
+#if os(macOS)
     let coordinate = interactionCoordinate(app: app, x: x, y: y)
-    #if os(macOS)
-      switch button {
-      case "primary":
-        coordinate.tap()
-      case "secondary":
-        coordinate.rightClick()
-      case "middle":
-        throw NSError(
-          domain: "AgentDeviceRunner",
-          code: 1,
-          userInfo: [NSLocalizedDescriptionKey: "middle mouse button is not supported"]
-        )
-      default:
-        throw NSError(
-          domain: "AgentDeviceRunner",
-          code: 1,
-          userInfo: [NSLocalizedDescriptionKey: "unsupported mouse button: \(button)"]
-        )
-      }
-    #else
+    switch button {
+    case "primary":
+      coordinate.tap()
+    case "secondary":
+      coordinate.rightClick()
+    case "middle":
+      throw NSError(
+        domain: "AgentDeviceRunner",
+        code: 1,
+        userInfo: [NSLocalizedDescriptionKey: "middle mouse button is not supported"]
+      )
+    default:
       throw NSError(
         domain: "AgentDeviceRunner",
         code: 1,
-        userInfo: [NSLocalizedDescriptionKey: "mouseClick is only supported on macOS"]
+        userInfo: [NSLocalizedDescriptionKey: "unsupported mouse button: \(button)"]
       )
-    #endif
+    }
+#elseif os(tvOS)
+    throw NSError(
+      domain: "AgentDeviceRunner",
+      code: 1,
+      userInfo: [NSLocalizedDescriptionKey: "mouseClick is not supported on tvOS"]
+    )
+#else
+    throw NSError(
+      domain: "AgentDeviceRunner",
+      code: 1,
+      userInfo: [NSLocalizedDescriptionKey: "mouseClick is only supported on macOS"]
+    )
+#endif
   }
 
-  func doubleTapAt(app: XCUIApplication, x: Double, y: Double) {
-    let coordinate = interactionCoordinate(app: app, x: x, y: y)
-    coordinate.doubleTap()
+  func doubleTapAt(app: XCUIApplication, x: Double, y: Double) -> RunnerInteractionOutcome {
+    if let outcome = selectFocusedTvElement(app: app, point: CGPoint(x: x, y: y), action: "double tap") {
+      guard case .performed = outcome else { return outcome }
+      sleepFor(0.1)
+      _ = pressTvRemote(.select)
+      return .performed
+    }
+    return performCoordinateDoubleTap(app: app, x: x, y: y)
   }
 
-  func longPressAt(app: XCUIApplication, x: Double, y: Double, duration: TimeInterval) {
-    let coordinate = interactionCoordinate(app: app, x: x, y: y)
-    coordinate.press(forDuration: duration)
+  func longPressAt(app: XCUIApplication, x: Double, y: Double, duration: TimeInterval) -> RunnerInteractionOutcome {
+    if let outcome = longSelectFocusedTvElement(app: app, point: CGPoint(x: x, y: y), duration: duration) {
+      return outcome
+    }
+    return performCoordinateLongPress(app: app, x: x, y: y, duration: duration)
   }
 
   func dragAt(
@@ -431,10 +438,17 @@ extension RunnerTests {
     x2: Double,
     y2: Double,
     holdDuration: TimeInterval
-  ) {
-    let start = interactionCoordinate(app: app, x: x, y: y)
-    let end = interactionCoordinate(app: app, x: x2, y: y2)
-    start.press(forDuration: holdDuration, thenDragTo: end)
+  ) -> RunnerInteractionOutcome {
+    // tvOS has no coordinate drag. Preserve the direction as a focus move.
+    let dx = x2 - x
+    let dy = y2 - y
+    let button: TvRemoteButton = abs(dx) > abs(dy)
+      ? (dx > 0 ? .right : .left)
+      : (dy > 0 ? .down : .up)
+    if pressTvRemote(button) {
+      return .performed
+    }
+    return performCoordinateDrag(app: app, x: x, y: y, x2: x2, y2: y2, holdDuration: holdDuration)
   }
 
   func resolvedTouchVisualizationFrame(app: XCUIApplication, x: Double, y: Double) -> TouchVisualizationFrame {
@@ -510,26 +524,28 @@ extension RunnerTests {
   }
 
   private func performTvRemoteSwipeIfAvailable(direction: String) -> Bool {
-#if os(tvOS)
     switch direction {
     case "up":
-      XCUIRemote.shared.press(.up)
+      return pressTvRemote(.up)
     case "down":
-      XCUIRemote.shared.press(.down)
+      return pressTvRemote(.down)
     case "left":
-      XCUIRemote.shared.press(.left)
+      return pressTvRemote(.left)
     case "right":
-      XCUIRemote.shared.press(.right)
+      return pressTvRemote(.right)
     default:
       return false
     }
-    return true
-#else
-    return false
-#endif
   }
 
-  func pinch(app: XCUIApplication, scale: Double, x: Double?, y: Double?) {
+  func pinch(app: XCUIApplication, scale: Double, x: Double?, y: Double?) -> RunnerInteractionOutcome {
+    return performCoordinatePinch(app: app, scale: scale, x: x, y: y)
+  }
+
+  private func performCoordinatePinch(app: XCUIApplication, scale: Double, x: Double?, y: Double?) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("pinch is not supported on tvOS")
+#else
     let target = app.windows.firstMatch.exists ? app.windows.firstMatch : app
 
     // Use double-tap + drag gesture for reliable map zoom
@@ -560,6 +576,8 @@ extension RunnerTests {
 
     // Immediately press and drag (second tap + drag)
     center.press(forDuration: 0.05, thenDragTo: endPoint)
+    return .performed
+#endif
   }
 
   private func interactionRoot(app: XCUIApplication) -> XCUIElement {
@@ -570,6 +588,52 @@ extension RunnerTests {
     return app
   }
 
+  private func performCoordinateTap(app: XCUIApplication, x: Double, y: Double) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("coordinate tap is not supported on tvOS; move focus with swipe or scroll, then select the focused element")
+#else
+    interactionCoordinate(app: app, x: x, y: y).tap()
+    return .performed
+#endif
+  }
+
+  private func performCoordinateDoubleTap(app: XCUIApplication, x: Double, y: Double) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("coordinate double tap is not supported on tvOS; move focus with swipe or scroll, then select the focused element")
+#else
+    interactionCoordinate(app: app, x: x, y: y).doubleTap()
+    return .performed
+#endif
+  }
+
+  private func performCoordinateLongPress(app: XCUIApplication, x: Double, y: Double, duration: TimeInterval) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("coordinate long press is not supported on tvOS; move focus with swipe or scroll, then long-select the focused element")
+#else
+    interactionCoordinate(app: app, x: x, y: y).press(forDuration: duration)
+    return .performed
+#endif
+  }
+
+  private func performCoordinateDrag(
+    app: XCUIApplication,
+    x: Double,
+    y: Double,
+    x2: Double,
+    y2: Double,
+    holdDuration: TimeInterval
+  ) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("coordinate drag is not supported on tvOS")
+#else
+    let start = interactionCoordinate(app: app, x: x, y: y)
+    let end = interactionCoordinate(app: app, x: x2, y: y2)
+    start.press(forDuration: holdDuration, thenDragTo: end)
+    return .performed
+#endif
+  }
+
+#if !os(tvOS)
   private func interactionCoordinate(app: XCUIApplication, x: Double, y: Double) -> XCUICoordinate {
     let root = interactionRoot(app: app)
     let origin = root.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
@@ -578,14 +642,17 @@ extension RunnerTests {
     let offsetY = y - Double(rootFrame.origin.y)
     return origin.withOffset(CGVector(dx: offsetX, dy: offsetY))
   }
+#endif
 
   private func tapElementCenter(app: XCUIApplication, element: XCUIElement) {
     let frame = element.frame
     if !frame.isEmpty {
-      tapAt(app: app, x: frame.midX, y: frame.midY)
+      _ = tapAt(app: app, x: frame.midX, y: frame.midY)
       return
     }
+#if !os(tvOS)
     element.tap()
+#endif
   }
 
   private func macOSNavigationBackElement(app: XCUIApplication) -> XCUIElement? {

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift

@@ -184,6 +184,7 @@ extension RunnerTests {
       .tap,
       .longPress,
       .drag,
+      .remotePress,
       .type,
       .swipe,
       .back,

package/ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift

@@ -8,6 +8,7 @@ enum CommandType: String, Codable {
   case interactionFrame
   case drag
   case dragSeries
+  case remotePress
   case type
   case swipe
   case findText
@@ -39,6 +40,7 @@ struct Command: Codable {
   let x: Double?
   let y: Double?
   let button: String?
+  let remoteButton: String?
   let count: Double?
   let intervalMs: Double?
   let doubleTap: Bool?
@@ -162,6 +164,7 @@ struct SnapshotNode: Codable {
   let value: String?
   let rect: SnapshotRect
   let enabled: Bool
+  let focused: Bool?
   let hittable: Bool
   let depth: Int
   let parentIndex: Int?