agent-device 0.20.10 → 0.21.1

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Alert.swift

@@ -22,6 +22,11 @@ extension RunnerTests {
   }
 
   func resolveAlert(app activeApp: XCUIApplication, deadline: Date) -> RunnerAlert? {
+
+
+
+
+
 #if !os(macOS)
     switch resolveBlockingSystemModal(deadline: deadline) {
     case .resolved(let modal):
@@ -32,10 +37,10 @@ extension RunnerTests {
       break
     }
 #endif
-    // Guard the query: when a remote-hosted modal (e.g. the AccessorySetupKit
-    // picker) was just dismissed, the dismissal re-check re-enters here with the
-    // now-gone host as `activeApp`, and its `alerts` query raises
-    // kAXErrorServerNotFound. safeElementsQuery absorbs it and reports no alert.
+
+
+
+
     if let alert = firstExistingElement(in: safeElementsQuery { activeApp.alerts.allElementsBoundByIndex }) {
       return runnerAlert(root: alert, ownerApp: activeApp, source: .appAlert)
     }
@@ -50,50 +55,34 @@ extension RunnerTests {
       guard let button = chooseAlertButton(alert.buttons, action: action) else {
         return Response(ok: false, error: ErrorPayload(message: "alert \(action) button not found"))
       }
-      let previousTitle = preferredAlertTitle(alert.root, buttons: alert.buttons)
-      let actionButtonLabel = button.label.trimmingCharacters(in: .whitespacesAndNewlines)
-      let actionButtonFrame = button.frame
+      guard Date() < deadline else {
+        return alertVerificationResponse(.timedOut, action: action, activated: false)
+      }
+      guard let original = captureAlertPresentation(alert.root) else {
+        return alertVerificationResponse(.unconfirmed, action: action, activated: false)
+      }
+      let observesApplicationRoot = alert.root.elementType == .application
+      guard Date() < deadline else {
+        return alertVerificationResponse(.timedOut, action: action, activated: false)
+      }
       let outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
       if let response = unsupportedResponse(for: outcome) {
         return response
       }
-      sleepFor(0.2)
-      if alertStillVisible(
-        in: alert.ownerApp,
-        source: alert.source,
-        previousTitle: previousTitle,
-        actionButtonLabel: actionButtonLabel,
-        deadline: deadline
-      ) {
-        if !actionButtonFrame.isNull && !actionButtonFrame.isEmpty {
-          let coordinateOutcome = tapAt(
-            app: alert.ownerApp,
-            x: actionButtonFrame.midX,
-            y: actionButtonFrame.midY
-          )
-          if let response = unsupportedResponse(for: coordinateOutcome) {
-            return response
-          }
-          sleepFor(0.2)
-        }
-      }
-      if alertStillVisible(
-        in: alert.ownerApp,
-        source: alert.source,
-        previousTitle: previousTitle,
-        actionButtonLabel: actionButtonLabel,
-        deadline: deadline
-      ) {
-        return Response(
-          ok: false,
-          error: ErrorPayload(
-            code: "INTERACTION_FAILED",
-            message: "alert \(action) did not dismiss the visible alert",
-            hint: "The alert button was found but the system still reports the alert after tapping it."
+      while true {
+        sleepFor(min(0.2, max(0, deadline.timeIntervalSinceNow)))
+        let verification = RunnerAlertVerification.verify(
+          original: original,
+          observation: observeAlert(
+            in: alert.ownerApp,
+            source: alert.source,
+            observesApplicationRoot: observesApplicationRoot,
+            deadline: deadline
           )
         )
+        if verification == .stillVisible { continue }
+        return alertVerificationResponse(verification, action: action, activated: true)
       }
-      return Response(ok: true, data: DataPayload(message: action == "accept" ? "accepted" : "dismissed"))
     }
 
     return Response(
@@ -130,57 +119,6 @@ extension RunnerTests {
     return RunnerAlert(root: root, ownerApp: ownerApp, buttons: buttons, source: source)
   }
 
-  private func alertStillVisible(
-    in ownerApp: XCUIApplication,
-    source: RunnerAlertSource,
-    previousTitle: String,
-    actionButtonLabel: String,
-    deadline: Date
-  ) -> Bool {
-    guard Date() < deadline,
-          let current = resolveAlert(source: source, app: ownerApp, deadline: deadline)
-    else {
-      return false
-    }
-    let currentTitle = preferredAlertTitle(current.root, buttons: current.buttons)
-    if previousTitle == currentTitle {
-      return true
-    }
-    return current.buttons.contains { button in
-      button.label.trimmingCharacters(in: .whitespacesAndNewlines) == actionButtonLabel
-    }
-  }
-
-  private func resolveAlert(
-    source: RunnerAlertSource,
-    app: XCUIApplication,
-    deadline: Date
-  ) -> RunnerAlert? {
-    switch source {
-    case .blockingSystemModal:
-#if os(macOS)
-      return nil
-#else
-      guard case .resolved(let modal) = resolveBlockingSystemModal(deadline: deadline) else {
-        return nil
-      }
-      return runnerAlert(modal)
-#endif
-    case .appAlert:
-      guard let alert = firstExistingElement(
-        in: safeElementsQuery { app.alerts.allElementsBoundByIndex }
-      ) else {
-        return nil
-      }
-      return runnerAlert(root: alert, ownerApp: app, source: .appAlert)
-    case .dismissPopup:
-      guard let popup = firstDismissPopupWindow(in: app) else {
-        return nil
-      }
-      return runnerAlert(root: popup, ownerApp: app, source: .dismissPopup)
-    }
-  }
-
   private func firstExistingElement(in elements: [XCUIElement]) -> XCUIElement? {
     elements.first { isVisibleElement($0) }
   }
@@ -226,6 +164,11 @@ extension RunnerTests {
   }
 
 
+
+
+
+
+
   private func isDismissButton(_ label: String) -> Bool {
     [
       "cancel",

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+AlertObservation.swift

@@ -0,0 +1,124 @@
+import XCTest
+
+extension RunnerTests {
+  func captureAlertPresentation(_ element: XCUIElement) -> RunnerAlertPresentation? {
+    var presentation: RunnerAlertPresentation?
+    _ = RunnerObjCExceptionCatcher.catchException {
+      guard let snapshot = try? element.snapshot() else { return }
+      presentation = self.alertPresentation(snapshot)
+    }
+    return presentation
+  }
+
+  func observeAlert(
+    in ownerApp: XCUIApplication,
+    source: RunnerAlertSource,
+    observesApplicationRoot: Bool,
+    deadline: Date
+  ) -> RunnerAlertObservation {
+    guard Date() < deadline else { return .deadlineExceeded }
+    var observation = RunnerAlertObservation.unavailable
+    _ = RunnerObjCExceptionCatcher.catchException {
+      switch ownerApp.state {
+      case .notRunning:
+        observation = .absent
+        return
+      case .runningForeground, .runningBackground:
+        break
+#if !os(macOS)
+      case .runningBackgroundSuspended:
+        break
+#endif
+      case .unknown:
+        return
+      @unknown default:
+        return
+      }
+      guard Date() < deadline, let snapshot = try? ownerApp.snapshot(),
+            !snapshot.children.isEmpty, !snapshot.frame.isNull, !snapshot.frame.isEmpty else { return }
+      if observesApplicationRoot {
+        observation = .visible(self.alertPresentation(snapshot))
+        return
+      }
+      let candidates = self.alertSnapshots(in: snapshot, source: source, viewport: snapshot.frame)
+      guard candidates.count <= 1 else { return }
+      observation = candidates.first.map { .visible(self.alertPresentation($0)) } ?? .absent
+    }
+    return Date() < deadline ? observation : .deadlineExceeded
+  }
+
+  private func alertSnapshots(
+    in snapshot: XCUIElementSnapshot,
+    source: RunnerAlertSource,
+    viewport: CGRect
+  ) -> [XCUIElementSnapshot] {
+    let frame = snapshot.frame
+    let visible = !frame.isNull && !frame.isEmpty && viewport.contains(CGPoint(x: frame.midX, y: frame.midY))
+    let matches: Bool
+    switch source {
+    case .blockingSystemModal:
+      matches = snapshot.elementType == .alert || snapshot.elementType == .sheet
+    case .appAlert:
+      matches = snapshot.elementType == .alert
+    case .dismissPopup:
+      matches = snapshot.elementType == .window && containsDismissPopupMarker(snapshot)
+    }
+    if matches && visible { return [snapshot] }
+    return snapshot.children.flatMap { alertSnapshots(in: $0, source: source, viewport: viewport) }
+  }
+
+  private func containsDismissPopupMarker(_ snapshot: XCUIElementSnapshot) -> Bool {
+    [snapshot.label, snapshot.identifier].contains {
+      $0.trimmingCharacters(in: .whitespacesAndNewlines).caseInsensitiveCompare("dismiss popup") == .orderedSame
+    } || snapshot.children.contains { containsDismissPopupMarker($0) }
+  }
+
+  private func alertPresentation(_ snapshot: XCUIElementSnapshot) -> RunnerAlertPresentation {
+    var content: [String] = []
+    var buttons: [String] = []
+    func collect(_ node: XCUIElementSnapshot) {
+      let label = node.label.trimmingCharacters(in: .whitespacesAndNewlines)
+      if actionableTypes.contains(node.elementType) {
+        buttons.append(label)
+      } else if !label.isEmpty {
+        content.append(label)
+      }
+      node.children.forEach(collect)
+    }
+    snapshot.children.forEach(collect)
+    return RunnerAlertPresentation(
+      title: snapshot.label.trimmingCharacters(in: .whitespacesAndNewlines),
+      content: content,
+      buttons: buttons
+    )
+  }
+
+  func alertVerificationResponse(
+    _ verification: RunnerAlertVerification,
+    action: String,
+    activated: Bool
+  ) -> Response {
+    let code: String
+    let message: String
+    switch verification {
+    case .disappeared, .presentationChanged:
+      return Response(ok: true, data: DataPayload(message: action == "accept" ? "accepted" : "dismissed"))
+    case .timedOut:
+      code = "ALERT_DEADLINE_EXCEEDED"
+      message = "alert \(action) exhausted its deadline"
+    case .stillVisible:
+      code = "INTERACTION_FAILED"
+      message = "alert \(action) still observes an unchanged alert presentation"
+    case .unconfirmed:
+      code = "ALERT_CONFIRMATION_UNAVAILABLE"
+      message = "alert \(action) could not read the alert presentation"
+    }
+    return Response(ok: false, error: ErrorPayload(
+      code: code,
+      message: message,
+      hint: activated
+        ? "The button was activated once. Inspect the current alert before deciding on another action."
+        : "No alert button was activated. Inspect the current alert before deciding on an action."
+    ))
+  }
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+BlockingSystemModalResolution.swift

@@ -46,8 +46,8 @@ extension RunnerTests {
     return .resolved(remoteModal)
   }
 
-  // AccessorySetupUI mirrors into SpringBoard, but its mirrored elements are not
-  // reliably hittable. Query the host directly; activating it breaks the picker.
+
+
   private static let remoteSystemModalHostBundleIds = [
     "com.apple.AccessorySetupUI"
   ]
@@ -60,8 +60,8 @@ extension RunnerTests {
       guard RemoteHostedSystemModalPolicy.isEligibleHostState(state) else { continue }
       guard Date() < deadline else { return nil }
 
-      // A dismissed remote host can raise kAXErrorServerNotFound. The safe queries
-      // inside actionableElements turn that disappearance into an empty result.
+
+
       let actions = actionableElements(in: host)
       guard !actions.isEmpty else { continue }
       return ResolvedBlockingSystemModal(root: host, ownerApp: host, actions: actions)
@@ -80,3 +80,38 @@ enum RemoteHostedSystemModalPolicy {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+