agent-device 0.20.10 → 0.21.1

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

@@ -2,30 +2,30 @@ import XCTest
 
 private enum KeyboardDismissObservationTiming {
   static let timeout: TimeInterval = 2
-  // #1542: dismissing the keyboard can trigger the host app's own content-offset
-  // adjustment (e.g. a ScrollView correcting the inset it grew to keep a focused
-  // field above the keyboard). That adjustment is a separate, unsynchronized
-  // animation the keyboard's own `waitForNonExistence` above knows nothing about:
-  // the keyboard AX element can vanish well before the app settles. The very next
-  // command is frequently a synthesized, AX-free drag (scroll/gesture — kept
-  // AX-free so it still works under #1105-family AX degradation), which has no
-  // XCTest quiescence wait of its own, so it can land mid-animation and net to
-  // zero. These bounds cap the settle wait this trades in.
-  // A spring-driven content-offset correction can pass through a near-zero-
-  // velocity inflection (the top of an overshoot) that two adjacent samples
-  // alone cannot distinguish from true rest. Requiring 3 consecutive matching
-  // samples demands ~2 full sample intervals of actual stillness before
-  // stopping early, so a momentary pause mid-animation cannot look settled.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   static let settleTimeout: TimeInterval = 2.0
   static let settleSampleInterval: TimeInterval = 0.15
   static let settleRequiredConsecutiveMatches: Int = 3
 }
 
-// The mechanism that actually resigned the keyboard, disclosed to the caller
-// (#1598) so a response never claims "dismissed" without saying how — a
-// safe-area tap has a very different reliability/side-effect profile than
-// tapping the keyboard's own Done key, and callers need to know which one
-// fired.
+
+
+
+
+
 enum RunnerKeyboardDismissMechanism: String {
   case dismissKey
 }
@@ -61,25 +61,25 @@ extension RunnerTests {
       return (wasVisible: true, dismissed: !visible, visible: visible, mechanism: visible ? nil : .dismissKey)
     }
 
-    // #1606 review P1 (twice): generic background-tap dismissal is
-    // deliberately UNSUPPORTED. No geometry or role query can prove a
-    // coordinate is side-effect-free — a full-screen unlabeled Pressable is
-    // indistinguishable from an inert backdrop, so a "safe-area" tap can
-    // navigate or submit while reporting a successful dismiss. The dismiss
-    // key is the only mechanism the runner can vouch for.
+
+
+
+
+
+
     return (wasVisible: true, dismissed: false, visible: isKeyboardVisible(app: app), mechanism: nil)
 #endif
   }
 
 
-  // AX-free on purpose (screenshot bytes, not the accessibility tree) so it holds
-  // under the same AX degradation the synthesized gesture lane is built to survive.
-  // Bounded and self-terminating: returns as soon as `requiredConsecutiveMatches`
-  // consecutive samples match, so an already-settled screen (the common case)
-  // pays close to nothing. The stopping decision itself
-  // (`runnerScreenshotStabilitySettled`) is a pure function of the samples taken
-  // so far, so it is unit-testable without a real screenshot pipeline; this loop
-  // is the thin, untestable I/O shell around it.
+
+
+
+
+
+
+
+
   private func waitForScreenshotStability(
     timeout: TimeInterval,
     sampleInterval: TimeInterval,
@@ -252,15 +252,15 @@ extension RunnerTests {
   }
 }
 
-/// True once the `requiredConsecutiveMatches` most recent samples are all present
-/// and byte-identical — i.e. the screen held still across that whole run of
-/// polls, not just the last two. A spring-driven content-offset correction can
-/// pass through a near-zero-velocity inflection that two adjacent samples alone
-/// cannot distinguish from true rest; requiring a longer run of matches demands
-/// real elapsed stillness before stopping early. `nil` entries (a screenshot
-/// capture that failed) never count toward a match, so a flaky capture cannot
-/// look like stability; the caller's bounded loop still terminates on its
-/// deadline regardless.
+
+
+
+
+
+
+
+
+
 func runnerScreenshotStabilitySettled(
   _ samples: [Data?],
   requiredConsecutiveMatches: Int
@@ -273,3 +273,62 @@ func runnerScreenshotStabilitySettled(
   return window.allSatisfy { $0 == firstData }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -22,7 +22,7 @@ func runnerCGImage(from image: RunnerImage) -> CGImage? {
 }
 
 extension RunnerTests {
-  // MARK: - Recording
+
 
   func captureRunnerFrame() -> RunnerImage? {
     var image: RunnerImage?
@@ -70,7 +70,7 @@ extension RunnerTests {
     return (NSTemporaryDirectory() as NSString).appendingPathComponent(safeFileName)
   }
 
-  // MARK: - Target Activation
+
 
   func ensureRunnerHostAppActive(reason: String) {
     NSLog(
@@ -103,12 +103,12 @@ extension RunnerTests {
 
   func resetTargetAfterExternalRelaunch() -> Response {
     invalidateCachedTarget(reason: "external_app_relaunch")
-    // The app process is replaced, but the retained runner survives. Clear
-    // process-bound capture state explicitly because invalidation drops the
-    // old PID before refreshCachedTargetIfProcessChanged can observe it.
+
+
+
     clearSnapshotXCTestChannelPenalty(reason: "external_app_relaunch")
     clearPrivateAXAcceptedDepth(reason: "external_app_relaunch")
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
     return Response(ok: true, data: DataPayload(message: "target reset"))
   }
 
@@ -132,7 +132,7 @@ extension RunnerTests {
     clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
     clearPrivateAXAcceptedDepth(reason: "target_process_changed")
     snapshotXCTestPenaltyWarmupExemptionPending = true
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
   }
 
   static func processIdentifier(of target: XCUIApplication) -> Int? {
@@ -191,7 +191,7 @@ extension RunnerTests {
       initialState.rawValue,
       reason
     )
-    // activate avoids terminating and relaunching the target app
+
     if initialState == .runningForeground {
       NSLog(
         "AGENT_DEVICE_RUNNER_ACTIVATE_SKIPPED bundle=%@ reason=already_foreground",
@@ -205,7 +205,7 @@ extension RunnerTests {
     currentAppProcessIdentifier = Self.processIdentifier(of: target)
     clearRememberedTextEntryTap()
     snapshotXCTestPenaltyWarmupExemptionPending = false
-    needsFirstInteractionDelay = true
+    beginFirstInteractionStabilization()
     return target
   }
 
@@ -229,7 +229,7 @@ extension RunnerTests {
     performWithQuiescenceSkippedIfSupported(target, operation: operation)
   }
 
-  // Some apps never report post-gesture quiescence, even after XCTest has synthesized the event.
+
   private func performWithQuiescenceSkippedIfSupported(
     _ target: XCUIApplication,
     operation: () -> Void
@@ -285,7 +285,7 @@ extension RunnerTests {
     return false
   }
 
-  // MARK: - Command Classification
+
 
   func isReadOnlyCommand(_ command: Command) -> Bool {
     switch command.command.traits.readOnly {
@@ -294,7 +294,7 @@ extension RunnerTests {
     case .never:
       return false
     case .conditional:
-      // Today only `alert` is conditional: read-only when getting, mutating otherwise.
+
       return (command.action ?? "get").lowercased() == "get"
     }
   }
@@ -313,22 +313,29 @@ extension RunnerTests {
     return command.traits.isLifecycle
   }
 
-  // MARK: - Interaction Stabilization
+
 
   func applyInteractionStabilizationIfNeeded() {
     if needsPostSnapshotInteractionDelay {
       sleepFor(postSnapshotInteractionDelay)
       needsPostSnapshotInteractionDelay = false
     }
-    if needsFirstInteractionDelay {
-      sleepFor(firstInteractionAfterActivateDelay)
-      needsFirstInteractionDelay = false
+    if let readyUptime = firstInteractionReadyUptime {
+      sleepFor(readyUptime - ProcessInfo.processInfo.systemUptime)
+      firstInteractionReadyUptime = nil
     }
   }
 
+
+
+  func beginFirstInteractionStabilization() {
+    firstInteractionReadyUptime =
+      ProcessInfo.processInfo.systemUptime + firstInteractionAfterActivateDelay
+  }
+
   func sleepFor(_ delay: TimeInterval) {
     guard delay > 0 else { return }
-    // Keep XCTest/UI sources moving during command-local pauses such as delayed typing.
+
     if Thread.isMainThread {
       let deadline = Date().addingTimeInterval(delay)
       while Date() < deadline {