@devicelab/maestro-runner-darwin-x64 1.1.25

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+SystemModal.swift

@@ -0,0 +1,230 @@
+import XCTest
+
+extension RunnerTests {
+  // MARK: - Blocking System Modal Snapshot
+
+  func blockingSystemAlertSnapshot() -> DataPayload? {
+    #if os(macOS)
+      return nil
+    #else
+    guard let modal = firstBlockingSystemModal(in: springboard) else {
+      return nil
+    }
+    let actions = actionableElements(in: modal)
+    guard !actions.isEmpty else {
+      return nil
+    }
+
+    let title = preferredSystemModalTitle(modal)
+    guard let modalNode = safeMakeSnapshotNode(
+      element: modal,
+      index: 0,
+      type: "Alert",
+      labelOverride: title,
+      identifierOverride: modal.identifier,
+      depth: 0,
+      hittableOverride: true
+    ) else {
+      return nil
+    }
+    var nodes: [SnapshotNode] = [modalNode]
+
+    for action in actions {
+      guard let actionNode = safeMakeSnapshotNode(
+        element: action,
+        index: nodes.count,
+        type: elementTypeName(action.elementType),
+        depth: 1,
+        hittableOverride: true
+      ) else {
+        continue
+      }
+      nodes.append(actionNode)
+    }
+
+    return DataPayload(nodes: nodes, truncated: false)
+    #endif
+  }
+
+  func firstBlockingSystemModal(in springboard: XCUIApplication) -> XCUIElement? {
+    let disableSafeProbe = RunnerEnv.isTruthy("AGENT_DEVICE_RUNNER_DISABLE_SAFE_MODAL_PROBE")
+    let queryElements: (() -> [XCUIElement]) -> [XCUIElement] = { fetch in
+      if disableSafeProbe {
+        return fetch()
+      }
+      return self.safeElementsQuery(fetch)
+    }
+
+    let alerts = queryElements {
+      springboard.alerts.allElementsBoundByIndex
+    }
+    for alert in alerts {
+      if safeIsBlockingSystemModal(alert, in: springboard) {
+        return alert
+      }
+    }
+
+    let sheets = queryElements {
+      springboard.sheets.allElementsBoundByIndex
+    }
+    for sheet in sheets {
+      if safeIsBlockingSystemModal(sheet, in: springboard) {
+        return sheet
+      }
+    }
+
+    return nil
+  }
+
+  func safeElementsQuery(_ fetch: () -> [XCUIElement]) -> [XCUIElement] {
+    var elements: [XCUIElement] = []
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      elements = fetch()
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_MODAL_QUERY_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return []
+    }
+    return elements
+  }
+
+  private func safeIsBlockingSystemModal(_ element: XCUIElement, in springboard: XCUIApplication) -> Bool {
+    var isBlocking = false
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      isBlocking = isBlockingSystemModal(element, in: springboard)
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_MODAL_CHECK_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return false
+    }
+    return isBlocking
+  }
+
+  private func isBlockingSystemModal(_ element: XCUIElement, in springboard: XCUIApplication) -> Bool {
+    guard element.exists else { return false }
+    let frame = element.frame
+    if frame.isNull || frame.isEmpty { return false }
+
+    let viewport = springboard.frame
+    if viewport.isNull || viewport.isEmpty { return false }
+
+    let center = CGPoint(x: frame.midX, y: frame.midY)
+    if !viewport.contains(center) { return false }
+
+    return true
+  }
+
+  func actionableElements(in element: XCUIElement) -> [XCUIElement] {
+    var seen = Set<String>()
+    var actions: [XCUIElement] = []
+    let descendants = safeElementsQuery {
+      element.descendants(matching: .any).allElementsBoundByIndex
+    }
+    for candidate in descendants {
+      if !safeIsActionableCandidate(candidate, seen: &seen) { continue }
+      actions.append(candidate)
+    }
+    return actions
+  }
+
+  private func safeIsActionableCandidate(_ candidate: XCUIElement, seen: inout Set<String>) -> Bool {
+    var include = false
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      if !candidate.exists || !candidate.isHittable { return }
+      if !actionableTypes.contains(candidate.elementType) { return }
+      let frame = candidate.frame
+      if frame.isNull || frame.isEmpty { return }
+      let key = "\(candidate.elementType.rawValue)-\(frame.origin.x)-\(frame.origin.y)-\(frame.size.width)-\(frame.size.height)-\(candidate.label)"
+      if seen.contains(key) { return }
+      seen.insert(key)
+      include = true
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_MODAL_ACTION_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return false
+    }
+    return include
+  }
+
+  private func preferredSystemModalTitle(_ element: XCUIElement) -> String {
+    let label = element.label
+    if !label.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+      return label
+    }
+    let identifier = element.identifier
+    if !identifier.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+      return identifier
+    }
+    return "System Alert"
+  }
+
+  private func makeSnapshotNode(
+    element: XCUIElement,
+    index: Int,
+    type: String,
+    labelOverride: String? = nil,
+    identifierOverride: String? = nil,
+    depth: Int,
+    hittableOverride: Bool? = nil
+  ) -> SnapshotNode {
+    let label = (labelOverride ?? element.label).trimmingCharacters(in: .whitespacesAndNewlines)
+    let identifier = (identifierOverride ?? element.identifier).trimmingCharacters(in: .whitespacesAndNewlines)
+    return SnapshotNode(
+      index: index,
+      type: type,
+      label: label.isEmpty ? nil : label,
+      identifier: identifier.isEmpty ? nil : identifier,
+      value: nil,
+      placeholderValue: nil,
+      rect: snapshotRect(from: element.frame),
+      enabled: element.isEnabled,
+      focused: elementHasFocus(element) ? true : nil,
+      selected: element.isSelected ? true : nil,
+      hittable: hittableOverride ?? element.isHittable,
+      depth: depth,
+      parentIndex: nil,
+      hiddenContentAbove: nil,
+      hiddenContentBelow: nil
+    )
+  }
+
+  private func safeMakeSnapshotNode(
+    element: XCUIElement,
+    index: Int,
+    type: String,
+    labelOverride: String? = nil,
+    identifierOverride: String? = nil,
+    depth: Int,
+    hittableOverride: Bool? = nil
+  ) -> SnapshotNode? {
+    var node: SnapshotNode?
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      node = makeSnapshotNode(
+        element: element,
+        index: index,
+        type: type,
+        labelOverride: labelOverride,
+        identifierOverride: identifierOverride,
+        depth: depth,
+        hittableOverride: hittableOverride
+      )
+    })
+    if let exceptionMessage {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_MODAL_NODE_IGNORED_EXCEPTION=%@",
+        exceptionMessage
+      )
+      return nil
+    }
+    return node
+  }
+}

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+Transport.swift

@@ -0,0 +1,137 @@
+import XCTest
+import Network
+
+extension RunnerTests {
+  // MARK: - Connection Lifecycle
+
+  func handle(connection: NWConnection) {
+    receiveRequest(connection: connection, buffer: Data())
+  }
+
+  // MARK: - Request Parsing
+
+  private func receiveRequest(connection: NWConnection, buffer: Data) {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 1024 * 1024) { [weak self] data, _, _, _ in
+      guard let self = self, let data = data else {
+        connection.cancel()
+        return
+      }
+      if buffer.count + data.count > self.maxRequestBytes {
+        let response = self.jsonResponse(
+          status: 413,
+          response: Response(ok: false, error: ErrorPayload(message: "request too large"))
+        )
+        self.sendResponse(response, over: connection) { [weak self] in
+          self?.finish()
+        }
+        return
+      }
+      let combined = buffer + data
+      if let body = self.parseRequest(data: combined) {
+        let result = self.handleRequestBody(body)
+        self.sendResponse(result.data, over: connection) { [weak self] in
+          if result.shouldFinish {
+            self?.finish()
+          }
+        }
+      } else {
+        self.receiveRequest(connection: connection, buffer: combined)
+      }
+    }
+  }
+
+  private func sendResponse(
+    _ response: Data,
+    over connection: NWConnection,
+    afterSend: @escaping () -> Void = {}
+  ) {
+    connection.send(content: response, isComplete: true, completion: .contentProcessed { error in
+      if let error {
+        NSLog("AGENT_DEVICE_RUNNER_SEND_FAILED=%@", String(describing: error))
+      }
+      connection.cancel()
+      afterSend()
+    })
+  }
+
+  private func parseRequest(data: Data) -> Data? {
+    guard let headerEnd = data.range(of: Data("\r\n\r\n".utf8)) else {
+      return nil
+    }
+    let headerData = data.subdata(in: 0..<headerEnd.lowerBound)
+    let bodyStart = headerEnd.upperBound
+    let headers = String(decoding: headerData, as: UTF8.self)
+    let contentLength = extractContentLength(headers: headers)
+    guard let contentLength = contentLength else {
+      return nil
+    }
+    if data.count < bodyStart + contentLength {
+      return nil
+    }
+    let body = data.subdata(in: bodyStart..<(bodyStart + contentLength))
+    return body
+  }
+
+  private func extractContentLength(headers: String) -> Int? {
+    for line in headers.split(separator: "\r\n") {
+      let parts = line.split(separator: ":", maxSplits: 1).map { $0.trimmingCharacters(in: .whitespaces) }
+      if parts.count == 2 && parts[0].lowercased() == "content-length" {
+        return Int(parts[1])
+      }
+    }
+    return nil
+  }
+
+  private func handleRequestBody(_ body: Data) -> (data: Data, shouldFinish: Bool) {
+    guard let json = String(data: body, encoding: .utf8) else {
+      return (
+        jsonResponse(status: 400, response: Response(ok: false, error: ErrorPayload(message: "invalid json"))),
+        false
+      )
+    }
+    guard let data = json.data(using: .utf8) else {
+      return (
+        jsonResponse(status: 400, response: Response(ok: false, error: ErrorPayload(message: "invalid json"))),
+        false
+      )
+    }
+
+    do {
+      let command = try JSONDecoder().decode(Command.self, from: data)
+      let response = try execute(command: command)
+      return (jsonResponse(status: 200, response: response), command.command == .shutdown)
+    } catch {
+      return (
+        jsonResponse(status: 500, response: Response(ok: false, error: ErrorPayload(message: "\(error)"))),
+        false
+      )
+    }
+  }
+
+  // MARK: - Response Encoding
+
+  private func jsonResponse(status: Int, response: Response) -> Data {
+    let encoder = JSONEncoder()
+    let body = (try? encoder.encode(response)).flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+    return httpResponse(status: status, body: body)
+  }
+
+  private func httpResponse(status: Int, body: String) -> Data {
+    let headers = [
+      "HTTP/1.1 \(status) OK",
+      "Content-Type: application/json",
+      "Content-Length: \(body.utf8.count)",
+      "Connection: close",
+      "",
+      body
+    ].joined(separator: "\r\n")
+    return Data(headers.utf8)
+  }
+
+  private func finish() {
+    NSLog("AGENT_DEVICE_RUNNER_EXIT reason=shutdown_command")
+    listener?.cancel()
+    listener = nil
+    doneExpectation?.fulfill()
+  }
+}

package/drivers/ios/DevicelabIOSRunner/DevicelabIOSRunnerUITests/RunnerTests+TvRemote.swift

@@ -0,0 +1,185 @@
+import XCTest
+
+enum RunnerInteractionOutcome {
+  case performed
+  case unsupported(String)
+}
+
+enum TvRemoteButton {
+  case select
+  case menu
+  case home
+  case up
+  case down
+  case left
+  case right
+}
+
+extension RunnerTests {
+  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
+  }
+
+  @discardableResult
+  func pressTvRemote(_ button: TvRemoteButton, duration: TimeInterval? = nil) -> Bool {
+#if os(tvOS)
+    let remoteButton = xcuiRemoteButton(button)
+    if let duration, duration > 0 {
+      XCUIRemote.shared.press(remoteButton, forDuration: duration)
+    } else {
+      XCUIRemote.shared.press(remoteButton)
+    }
+    return true
+#else
+    return false
+#endif
+  }
+
+  func tvRemoteButton(from raw: String?) -> TvRemoteButton? {
+    switch raw?.lowercased() {
+    case "select":
+      return .select
+    case "menu":
+      return .menu
+    case "home":
+      return .home
+    case "up":
+      return .up
+    case "down":
+      return .down
+    case "left":
+      return .left
+    case "right":
+      return .right
+    default:
+      return nil
+    }
+  }
+
+  func elementHasFocus(_ element: XCUIElement) -> Bool {
+    var focused = false
+    _ = RunnerObjCExceptionCatcher.catchException({
+      if let value = (element as NSObject).value(forKey: "hasFocus") as? Bool {
+        focused = value
+      }
+    })
+    return focused
+  }
+
+  func activateElement(app: XCUIApplication, element: XCUIElement, action: String) -> RunnerInteractionOutcome {
+    if let outcome = selectFocusedTvElement(app: app, element: element, action: action) {
+      return outcome
+    }
+    return performElementTap(element)
+  }
+
+  func selectFocusedTvElement(app: XCUIApplication, point: CGPoint, action: String) -> RunnerInteractionOutcome? {
+#if os(tvOS)
+    guard let focused = focusedTvElement(app: app), !focused.frame.isEmpty, focused.frame.contains(point) else {
+      return .unsupported("\(action) is supported on tvOS only when the requested point is inside the focused element")
+    }
+    _ = pressTvRemote(.select)
+    return .performed
+#else
+    return nil
+#endif
+  }
+
+  func longSelectFocusedTvElement(app: XCUIApplication, point: CGPoint, duration: TimeInterval) -> RunnerInteractionOutcome? {
+#if os(tvOS)
+    guard let focused = focusedTvElement(app: app), !focused.frame.isEmpty, focused.frame.contains(point) else {
+      return .unsupported("long press is supported on tvOS only when the requested point is inside the focused element")
+    }
+    _ = pressTvRemote(.select, duration: duration)
+    return .performed
+#else
+    return nil
+#endif
+  }
+
+  private func performElementTap(_ element: XCUIElement) -> RunnerInteractionOutcome {
+#if os(tvOS)
+    return .unsupported("element tap is not supported on tvOS; move focus with swipe or scroll, then select the focused element")
+#else
+    element.tap()
+    return .performed
+#endif
+  }
+
+  private func selectFocusedTvElement(app: XCUIApplication, element: XCUIElement, action: String) -> RunnerInteractionOutcome? {
+#if os(tvOS)
+    guard tvFocusedElementMatches(app: app, target: element) else {
+      return .unsupported("\(action) is supported on tvOS only when the requested element is focused")
+    }
+    _ = pressTvRemote(.select)
+    return .performed
+#else
+    return nil
+#endif
+  }
+
+  private func tvFocusedElementMatches(app: XCUIApplication, target: XCUIElement) -> Bool {
+#if os(tvOS)
+    if target.hasFocus {
+      return true
+    }
+    guard let focused = focusedTvElement(app: app) else {
+      return false
+    }
+    let targetFrame = target.frame
+    let focusedFrame = focused.frame
+    guard !targetFrame.isEmpty && !focusedFrame.isEmpty else {
+      return false
+    }
+    let focusedCenter = CGPoint(x: focusedFrame.midX, y: focusedFrame.midY)
+    let targetCenter = CGPoint(x: targetFrame.midX, y: targetFrame.midY)
+    return targetFrame.contains(focusedCenter)
+      || focusedFrame.contains(targetCenter)
+      || targetFrame.intersects(focusedFrame)
+#else
+    return false
+#endif
+  }
+
+  private func focusedTvElement(app: XCUIApplication) -> XCUIElement? {
+#if os(tvOS)
+    let focused = app
+      .descendants(matching: .any)
+      .matching(NSPredicate(format: "hasFocus == true"))
+      .firstMatch
+    return focused.exists ? focused : nil
+#else
+    return nil
+#endif
+  }
+
+#if os(tvOS)
+  private func xcuiRemoteButton(_ button: TvRemoteButton) -> XCUIRemote.Button {
+    switch button {
+    case .select:
+      return .select
+    case .menu:
+      return .menu
+    case .home:
+      return .home
+    case .up:
+      return .up
+    case .down:
+      return .down
+    case .left:
+      return .left
+    case .right:
+      return .right
+    }
+  }
+#endif
+}