agent-device 0.21.2 → 0.21.4

package/android/ime-helper/dist/agent-device-android-ime-helper-0.21.4.apk.sha256

@@ -0,0 +1 @@
+fdf9f5946ee579efe8ef31eb43865d19706dba5f78c75bf908a0e3daf6b7a163  agent-device-android-ime-helper-0.21.4.apk

package/android/ime-helper/dist/{agent-device-android-ime-helper-0.21.2.manifest.json → agent-device-android-ime-helper-0.21.4.manifest.json}

@@ -1,10 +1,10 @@
 {
   "name": "android-ime-helper",
-  "version": "0.21.2",
-  "assetName": "agent-device-android-ime-helper-0.21.2.apk",
-  "sha256": "17a3645b2baca245adaa37e025a89eb35da7c5c6d53ae2d2d84862474f402cf0",
+  "version": "0.21.4",
+  "assetName": "agent-device-android-ime-helper-0.21.4.apk",
+  "sha256": "fdf9f5946ee579efe8ef31eb43865d19706dba5f78c75bf908a0e3daf6b7a163",
   "packageName": "com.callstack.agentdevice.imehelper",
-  "versionCode": 21002,
+  "versionCode": 21004,
   "serviceComponent": "com.callstack.agentdevice.imehelper/.TestInputMethodService",
   "broadcastProtocol": "android-ime-helper-v1"
 }

package/android/snapshot-helper/dist/agent-device-android-snapshot-helper-0.21.4.apk.sha256

@@ -0,0 +1 @@
+9fae32c14211310223ba7f6cdf19433d03f01d01e5dc24d1e5b3294cd80ad501  agent-device-android-snapshot-helper-0.21.4.apk

package/android/snapshot-helper/dist/agent-device-android-snapshot-helper-0.21.4.manifest.json

@@ -0,0 +1,16 @@
+{
+  "name": "android-snapshot-helper",
+  "version": "0.21.4",
+  "releaseTag": "v0.21.4",
+  "assetName": "agent-device-android-snapshot-helper-0.21.4.apk",
+  "apkUrl": null,
+  "sha256": "9fae32c14211310223ba7f6cdf19433d03f01d01e5dc24d1e5b3294cd80ad501",
+  "checksumName": "agent-device-android-snapshot-helper-0.21.4.apk.sha256",
+  "packageName": "com.callstack.agentdevice.snapshothelper",
+  "versionCode": 21004,
+  "instrumentationRunner": "com.callstack.agentdevice.snapshothelper/.SnapshotInstrumentation",
+  "minSdk": 23,
+  "targetSdk": 36,
+  "outputFormat": "uiautomator-xml",
+  "statusProtocol": "android-snapshot-helper-v1"
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunner/AgentDeviceRunnerApp.m

@@ -62,11 +62,46 @@ int main(int argc, const char *argv[]) {
 @property(nonatomic, assign) NSUInteger firstAlertActions;
 @property(nonatomic, assign) NSUInteger replacementAlertActions;
 @property(nonatomic, assign) BOOL alertFixtureStarted;
+@property(nonatomic, strong) NSTimer *alertActivationBusyBackstop;
 @end
 
 @implementation AgentDeviceRunnerViewController
 
 #if TARGET_OS_IOS
+// An animation that never ends is what "busy" looks like to XCTest while it decides whether the app
+// may receive an event: the app keeps reporting work in flight, which is the state that cost an alert
+// command its whole deadline in #2546. It stops the moment an alert button is answered, since that
+// answer is the event the runner is trying to land, and the backstop stops it even when no answer
+// arrives so a regressed run finishes rather than waiting out XCTest's own timeout. A layer
+// animation on its own is not enough; only a UIView animation counts as in-flight work here.
+static NSTimeInterval const kAgentDeviceAlertActivationBusyWindow = 20.0;
+
+- (void)startAlertActivationBusy {
+  if (self.alertActivationBusyBackstop != nil) {
+    return;
+  }
+  self.alertActivationBusyBackstop = [NSTimer scheduledTimerWithTimeInterval:kAgentDeviceAlertActivationBusyWindow
+                                                                      target:self
+                                                                    selector:@selector(stopAlertActivationBusy)
+                                                                    userInfo:nil
+                                                                     repeats:NO];
+  [UIView animateWithDuration:0.4
+                          delay:0
+                        options:(UIViewAnimationOptionRepeat | UIViewAnimationOptionAutoreverse)
+                     animations:^{
+                       self.alertActionStatus.transform = CGAffineTransformMakeTranslation(0, 8);
+                     }
+                     completion:nil];
+}
+
+- (void)stopAlertActivationBusy {
+  [self.alertActionStatus.layer removeAllAnimations];
+  self.alertActionStatus.transform = CGAffineTransformIdentity;
+  [self.alertActivationBusyBackstop invalidate];
+  self.alertActivationBusyBackstop = nil;
+}
+
+
 - (void)updateAlertActionStatus {
   self.alertActionStatus.text = [NSString stringWithFormat:@"First actions: %lu; replacement actions: %lu",
                                                          (unsigned long)self.firstAlertActions,
@@ -88,6 +123,7 @@ int main(int argc, const char *argv[]) {
         ? UIAlertActionStyleCancel : UIAlertActionStyleDefault;
     [alert addAction:[UIAlertAction actionWithTitle:buttonTitle style:style handler:^(UIAlertAction *action) {
       (void)action;
+      [self stopAlertActivationBusy];
       if (replacement) {
         self.replacementAlertActions += 1;
       } else {
@@ -110,6 +146,9 @@ int main(int argc, const char *argv[]) {
       [NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-alert-replacement-regression"]) {
     self.alertFixtureStarted = YES;
     [self presentAlertFixtureReplacement:NO];
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--agent-device-alert-activation-busy"]) {
+      [self startAlertActivationBusy];
+    }
   }
 }
 #endif

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSystemSurfaceHostPolicy.swift

@@ -4,8 +4,10 @@ import Foundation
 
 
 
+
 enum SystemSurfaceHostKind: String {
   case webAuth = "web-auth"
+  case payment = "payment"
 }
 
 struct SystemSurfaceHost: Equatable {
@@ -15,7 +17,8 @@ struct SystemSurfaceHost: Equatable {
 
 enum SystemSurfaceHostRegistry {
   static let hosts: [SystemSurfaceHost] = [
-    SystemSurfaceHost(bundleId: "com.apple.SafariViewService", kind: .webAuth)
+    SystemSurfaceHost(bundleId: "com.apple.SafariViewService", kind: .webAuth),
+    SystemSurfaceHost(bundleId: "com.apple.PassbookUIService", kind: .payment),
   ]
 
   static func host(forBundleId bundleId: String?) -> SystemSurfaceHost? {
@@ -64,6 +67,11 @@ enum SystemSurfaceHostRegistry {
 
 
 
+
+
+
+
+
 
 
 

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

@@ -266,7 +266,7 @@ extension RunnerTests {
 
 
   func shouldReadPrivateAXViewportViaXCTest() -> Bool {
-    !hasAbandonedTreeCapture() && !isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
+    !hasAbandonedMainThreadWork() && !isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
   }
 
   private func privateAXSnapshotViewport(app: XCUIApplication, rootFrame: CGRect) -> CGRect {
@@ -276,6 +276,7 @@ extension RunnerTests {
     }
     do {
       let viewport = try runMainThreadWork(
+        "private_ax_viewport",
         timeout: 1,
         timeoutError: snapshotMainThreadTimeoutError("reading private AX viewport")
       ) {

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

@@ -68,7 +68,16 @@ extension RunnerTests {
       guard waitUntilAlertButtonHittable(button, deadline: deadline) else {
         return alertVerificationResponse(.timedOut, action: action, activated: false)
       }
-      let outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
+
+
+
+
+
+
+      var outcome = RunnerInteractionOutcome.performed
+      withBoundedInteractionIdleTimeoutIfSupported(alert.ownerApp, waits: .preEventSkipped) {
+        outcome = activateElement(app: alert.ownerApp, element: button, action: "alert \(action)")
+      }
       if let response = unsupportedResponse(for: outcome) {
         return response
       }

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

@@ -97,7 +97,9 @@ extension RunnerTests {
     var outcome = RunnerInteractionOutcome.performed
     let timing = measureGesture {
       if idleTimeout {
-        withTemporaryScrollIdleTimeoutIfSupported(app) { outcome = action() }
+        withBoundedInteractionIdleTimeoutIfSupported(app, waits: .bothSkipped) {
+          outcome = action()
+        }
       } else {
         outcome = action()
       }
@@ -896,29 +898,6 @@ extension RunnerTests {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 
@@ -977,13 +956,6 @@ extension RunnerTests {
     )
   }
 
-
-
-  private final class MainThreadWorkState {
-    var finished = false
-    var abandoned = false
-  }
-
   struct ActiveCommandContext {
     let app: XCUIApplication
 
@@ -995,23 +967,6 @@ extension RunnerTests {
     case context(ActiveCommandContext)
   }
 
-  enum MainThreadBusyState {
-    case idle
-    case busy(abandonedForSeconds: TimeInterval)
-    case wedged(abandonedForSeconds: TimeInterval)
-  }
-
-  func currentMainThreadBusyState() -> MainThreadBusyState {
-    mainThreadWorkLock.lock()
-    defer { mainThreadWorkLock.unlock() }
-    guard abandonedMainThreadWorkCount > 0 else { return .idle }
-    let abandonedFor = abandonedMainThreadWorkSince.map { Date().timeIntervalSince($0) } ?? 0
-    if abandonedFor > mainThreadWedgeThreshold {
-      return .wedged(abandonedForSeconds: abandonedFor)
-    }
-    return .busy(abandonedForSeconds: abandonedFor)
-  }
-
   private func runnerBusyResponse(command: Command, abandonedForSeconds: TimeInterval) -> Response {
     NSLog(
       "AGENT_DEVICE_RUNNER_BUSY command=%@ commandId=%@ abandonedForSeconds=%.1f",
@@ -1092,6 +1047,7 @@ extension RunnerTests {
     }
     if command.command == .alert, let deadline = alertDeadline {
       return try runMainThreadWork(
+        "command_execution",
         timeout: max(0.001, deadline.timeIntervalSinceNow),
         timeoutError: mainThreadExecutionTimeoutError
       ) {
@@ -1103,6 +1059,7 @@ extension RunnerTests {
       }
     }
     return try runMainThreadWork(
+      "command_execution",
       timeout: mainThreadExecutionTimeout,
       timeoutError: mainThreadExecutionTimeoutError
     ) {
@@ -1110,77 +1067,6 @@ extension RunnerTests {
     }
   }
 
-  func runMainThreadWork<T>(
-    timeout: TimeInterval,
-    timeoutError: @escaping () -> Error,
-    onAbandoned: (() -> Void)? = nil,
-    onDrained: (() -> Void)? = nil,
-    _ work: @escaping () throws -> T
-  ) throws -> T {
-    if Thread.isMainThread {
-      return try work()
-    }
-    var result: Result<T, Error>?
-    let semaphore = DispatchSemaphore(value: 0)
-    let workState = MainThreadWorkState()
-    DispatchQueue.main.async {
-      do {
-        result = .success(try work())
-      } catch {
-        result = .failure(error)
-      }
-      self.mainThreadWorkLock.lock()
-      if workState.abandoned {
-        self.abandonedMainThreadWorkCount -= 1
-        if self.abandonedMainThreadWorkCount == 0 {
-          self.abandonedMainThreadWorkSince = nil
-          NSLog("AGENT_DEVICE_RUNNER_ABANDONED_WORK_DRAINED")
-        }
-        self.mainThreadWorkLock.unlock()
-        onDrained?()
-      } else {
-        workState.finished = true
-        self.mainThreadWorkLock.unlock()
-      }
-      semaphore.signal()
-    }
-    let waitResult = semaphore.wait(timeout: .now() + timeout)
-    if waitResult == .timedOut {
-      mainThreadWorkLock.lock()
-      let stillRunning = !workState.finished
-      if stillRunning {
-        workState.abandoned = true
-        abandonedMainThreadWorkCount += 1
-        if abandonedMainThreadWorkSince == nil {
-          abandonedMainThreadWorkSince = Date()
-        }
-        onAbandoned?()
-      }
-      mainThreadWorkLock.unlock()
-      throw timeoutError()
-    }
-    switch result {
-    case .success(let value):
-      return value
-    case .failure(let error):
-      throw error
-    case .none:
-      throw NSError(
-        domain: RunnerErrorDomain.general,
-        code: RunnerErrorCode.noResponseFromMainThread,
-        userInfo: [NSLocalizedDescriptionKey: "no response from main thread"]
-      )
-    }
-  }
-
-  private func mainThreadExecutionTimeoutError() -> Error {
-    NSError(
-      domain: RunnerErrorDomain.general,
-      code: RunnerErrorCode.mainThreadExecutionTimedOut,
-      userInfo: [NSLocalizedDescriptionKey: "main thread execution timed out"]
-    )
-  }
-
 
 
   private func executeOnMainSafely(
@@ -1282,6 +1168,7 @@ extension RunnerTests {
     var hasRetried = false
     while true {
       let failureCountBefore = try runMainThreadWork(
+        "recorded_failure_count",
         timeout: mainThreadExecutionTimeout,
         timeoutError: mainThreadExecutionTimeoutError
       ) {
@@ -1290,7 +1177,7 @@ extension RunnerTests {
       let response = try perform()
 
 
-      if hasAbandonedTreeCapture() {
+      if hasAbandonedMainThreadWork() {
         NSLog(
           "AGENT_DEVICE_RUNNER_DISPATCH_RECOVERY_SKIPPED_XCTEST_OCCUPIED command=%@",
           command.command.rawValue
@@ -1298,6 +1185,7 @@ extension RunnerTests {
         return response
       }
       let recordedFailureResponse = try runMainThreadWork(
+        "recorded_failure_count",
         timeout: mainThreadExecutionTimeout,
         timeoutError: mainThreadExecutionTimeoutError
       ) {
@@ -1307,6 +1195,7 @@ extension RunnerTests {
       }
       if let recordedFailureResponse {
         try runMainThreadWork(
+          "target_invalidation",
           timeout: mainThreadExecutionTimeout,
           timeoutError: mainThreadExecutionTimeoutError
         ) {
@@ -1321,6 +1210,7 @@ extension RunnerTests {
         )
         hasRetried = true
         try runMainThreadWork(
+          "target_invalidation",
           timeout: mainThreadExecutionTimeout,
           timeoutError: mainThreadExecutionTimeoutError
         ) {
@@ -1335,6 +1225,7 @@ extension RunnerTests {
 
   private func executeSnapshotDispatchedOnce(command: Command) throws -> Response {
     let preparation = try runMainThreadWork(
+      "command_preparation",
       timeout: mainThreadExecutionTimeout,
       timeoutError: mainThreadExecutionTimeoutError
     ) {
@@ -1409,12 +1300,13 @@ extension RunnerTests {
       needsPostSnapshotInteractionDelay = true
       return
     }
-    guard !hasAbandonedTreeCapture() else {
+    guard !hasAbandonedMainThreadWork() else {
       NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_SKIPPED_XCTEST_OCCUPIED")
       return
     }
     do {
       try runMainThreadWork(
+        "post_snapshot_delay_mark",
         timeout: 1,
         timeoutError: mainThreadExecutionTimeoutError
       ) {
@@ -1430,8 +1322,18 @@ extension RunnerTests {
       invalidateCachedTarget(reason: "ax_snapshot_failure")
       return
     }
+
+
+    guard !hasAbandonedMainThreadWork() else {
+      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_INVALIDATION_DEFERRED_XCTEST_OCCUPIED")
+      DispatchQueue.main.async {
+        self.invalidateCachedTarget(reason: "ax_snapshot_failure")
+      }
+      return
+    }
     do {
       try runMainThreadWork(
+        "target_invalidation",
         timeout: 1,
         timeoutError: mainThreadExecutionTimeoutError
       ) {
@@ -2075,7 +1977,7 @@ extension RunnerTests {
       return Response(ok: true, data: DataPayload(message: "remote pressed"))
     case .type:
       var response: Response?
-      withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
+      withBoundedInteractionIdleTimeoutIfSupported(activeApp, waits: .bothSkipped) {
         response = executeTypeCommand(activeApp: activeApp, command: command)
       }
       return response ?? Response(ok: false, error: ErrorPayload(message: "type produced no response"))
@@ -2087,7 +1989,7 @@ extension RunnerTests {
 
       var executedFrame: DragVisualizationFrame?
       let timing = measureGesture {
-        withTemporaryScrollIdleTimeoutIfSupported(activeApp) {
+        withBoundedInteractionIdleTimeoutIfSupported(activeApp, waits: .bothSkipped) {
           executedFrame = swipe(app: activeApp, direction: direction)
         }
       }
@@ -2187,7 +2089,7 @@ extension RunnerTests {
             code: "UNSUPPORTED_OPERATION",
             message: "Unable to dismiss the iOS keyboard: the keyboard exposes no dismiss key, and background taps are never attempted (no tap outside the keyboard can be proven side-effect-free)",
             hint:
-              "The on-screen keyboard usually does not block agent-device interactions: press the next target directly instead of retrying dismiss. If that press fails or reports no visible effect, scroll the target into view, or use keyboard enter to press the return key when submission is wanted."
+              "An element whose center sits behind the on-screen keyboard is refused with tap_keyboard_occludes_target; one whose center stays above the keys presses normally. To end editing, tap the app's own Done/Cancel control, or use keyboard enter to press the return key when submission is wanted."
           )
         )
       }

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

@@ -415,6 +415,52 @@ final class RunnerCommandJournal {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

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

@@ -21,6 +21,24 @@ func runnerCGImage(from image: RunnerImage) -> CGImage? {
 #endif
 }
 
+
+
+
+
+
+
+
+enum RunnerInteractionIdleWaits {
+
+
+
+  case bothSkipped
+
+
+
+  case preEventSkipped
+}
+
 extension RunnerTests {
 
 
@@ -209,8 +227,14 @@ extension RunnerTests {
     return target
   }
 
-  func withTemporaryScrollIdleTimeoutIfSupported(
+
+
+
+
+
+  func withBoundedInteractionIdleTimeoutIfSupported(
     _ target: XCUIApplication,
+    waits: RunnerInteractionIdleWaits,
     operation: () -> Void
   ) {
     let setter = NSSelectorFromString("setWaitForIdleTimeout:")
@@ -219,19 +243,20 @@ extension RunnerTests {
       ? (target.value(forKey: "waitForIdleTimeout") as? NSNumber)
       : nil
     if supportsWaitForIdleTimeout {
-      target.setValue(scrollInteractionIdleTimeoutDefault, forKey: "waitForIdleTimeout")
+      target.setValue(interactionIdleTimeoutDefault, forKey: "waitForIdleTimeout")
     }
     defer {
       if let previous {
         target.setValue(previous.doubleValue, forKey: "waitForIdleTimeout")
       }
     }
-    performWithQuiescenceSkippedIfSupported(target, operation: operation)
+    performWithQuiescenceSkippedIfSupported(target, waits: waits, operation: operation)
   }
 
 
   private func performWithQuiescenceSkippedIfSupported(
     _ target: XCUIApplication,
+    waits: RunnerInteractionIdleWaits,
     operation: () -> Void
   ) {
     let selector = NSSelectorFromString("_performWithInteractionOptions:block:")
@@ -252,12 +277,19 @@ extension RunnerTests {
     )
     let skipPreEventQuiescence = UInt(1)
     let skipPostEventQuiescence = UInt(2)
+    let options: UInt
+    switch waits {
+    case .bothSkipped:
+      options = skipPreEventQuiescence | skipPostEventQuiescence
+    case .preEventSkipped:
+      options = skipPreEventQuiescence
+    }
     withoutActuallyEscaping(operation) { escapableOperation in
       let block: @convention(block) () -> Void = escapableOperation
       performWithOptions(
         target,
         selector,
-        skipPreEventQuiescence | skipPostEventQuiescence,
+        options,
         block
       )
     }