agent-device 0.21.12 → 0.21.14

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

@@ -0,0 +1,106 @@
+import XCTest
+
+
+
+
+
+
+
+
+
+
+struct SnapshotCaptureTarget {
+  let app: XCUIApplication
+  let bundleId: String?
+  let processIdentifier: Int?
+}
+
+
+enum SnapshotCommandPreparation {
+  case response(Response)
+  case capture(SnapshotCaptureTarget, systemSurface: SystemSurfaceHost?)
+}
+
+
+
+
+
+
+
+
+enum SnapshotProbePenaltyTarget: Equatable {
+
+  case prepared(bundleId: String?)
+
+  case mainOwnedTarget
+}
+
+
+
+final class SnapshotProbePenaltyIdentity {
+  private let lock = NSLock()
+  private var bundleId: String?
+  private let readsMainOwnedTarget: Bool
+
+  init(_ target: SnapshotProbePenaltyTarget) {
+    readsMainOwnedTarget = target == .mainOwnedTarget
+    if case .prepared(let bundleId) = target {
+      self.bundleId = bundleId
+    }
+  }
+
+
+
+  func captureFromMain(bundleId: String?) {
+    guard readsMainOwnedTarget else { return }
+    lock.lock()
+    self.bundleId = bundleId
+    lock.unlock()
+  }
+
+  var penalizedBundleId: String? {
+    lock.lock()
+    defer { lock.unlock() }
+    return bundleId
+  }
+}
+
+extension RunnerTests {
+
+  func takeSnapshotCaptureTarget(app: XCUIApplication) -> SnapshotCaptureTarget {
+    SnapshotCaptureTarget(
+      app: app,
+      bundleId: currentBundleId,
+      processIdentifier: currentAppProcessIdentifier
+    )
+  }
+
+
+
+
+  func applyMainOwnedSnapshotState(_ operation: String, _ write: @escaping () -> Void) {
+    if Thread.isMainThread {
+      write()
+      return
+    }
+    guard !hasAbandonedMainThreadWork() else {
+      NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_STATE_DEFERRED_XCTEST_OCCUPIED operation=%@", operation)
+      DispatchQueue.main.async(execute: write)
+      return
+    }
+    do {
+      try runMainThreadWork(
+        operation,
+        timeout: 1,
+        timeoutError: mainThreadExecutionTimeoutError,
+        write
+      )
+    } catch {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_SNAPSHOT_STATE_FAILED operation=%@ error=%@",
+        operation,
+        String(describing: error)
+      )
+    }
+  }
+}

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

@@ -0,0 +1,142 @@
+import XCTest
+import AgentDeviceSnapshotPresentation
+
+extension RunnerTests {
+  func executeSnapshotDispatched(command: Command) throws -> Response {
+    try executeDispatchedWithRecovery(command: command) {
+      try self.executeSnapshotDispatchedOnce(command: command)
+    }
+  }
+
+  private func executeSnapshotDispatchedOnce(command: Command) throws -> Response {
+    let preparation: SnapshotCommandPreparation = try runMainThreadWork(
+      "command_preparation",
+      timeout: mainThreadExecutionTimeout,
+      timeoutError: mainThreadExecutionTimeoutError
+    ) { () -> SnapshotCommandPreparation in
+      switch try self.prepareActiveCommandContextSafely(command: command, routeToSpringboard: false) {
+      case .response(let response):
+        return .response(response)
+      case .context(let context):
+        return .capture(
+          self.takeSnapshotCaptureTarget(app: context.app),
+          systemSurface: context.systemSurface
+        )
+      }
+    }
+    switch preparation {
+    case .response(let response):
+      return response
+    case .capture(let target, let systemSurface):
+      return try executeSnapshotPrepared(
+        command: command,
+        target: target,
+        systemSurface: systemSurface
+      )
+    }
+  }
+
+  private func prepareActiveCommandContextSafely(
+    command: Command,
+    routeToSpringboard: Bool
+  ) throws -> ActiveCommandPreparation {
+    var preparation: ActiveCommandPreparation?
+    let exceptionMessage = RunnerObjCExceptionCatcher.catchException({
+      preparation = self.prepareActiveCommandContext(
+        command: command,
+        routeToSpringboard: routeToSpringboard
+      )
+    })
+    if let exceptionMessage {
+      throw NSError(
+        domain: RunnerErrorDomain.exception,
+        code: RunnerErrorCode.objcException,
+        userInfo: [NSLocalizedDescriptionKey: exceptionMessage]
+      )
+    }
+    guard let preparation else {
+      throw NSError(
+        domain: RunnerErrorDomain.general,
+        code: RunnerErrorCode.commandReturnedNoResponse,
+        userInfo: [NSLocalizedDescriptionKey: "snapshot preflight returned no response"]
+      )
+    }
+    return preparation
+  }
+
+
+
+  static func presentationOptions(from command: Command) -> PresentationOptions {
+    let customActions = command.customActions ?? false
+    return PresentationOptions(
+      interactiveOnly: command.interactiveOnly ?? false,
+      depth: command.depth,
+      scope: command.scope,
+      raw: command.raw ?? false,
+
+
+
+      preferredBackend: command.preferredBackend
+        ?? (customActions ? SnapshotBackendKind.privateAX.rawValue : nil),
+      customActions: customActions
+    )
+  }
+
+  private func executeSnapshotPrepared(
+    command: Command,
+    target: SnapshotCaptureTarget,
+    systemSurface: SystemSurfaceHost?
+  ) throws -> Response {
+    let options = Self.presentationOptions(from: command)
+    do {
+      var payload: DataPayload
+      if options.raw {
+        payload = try snapshotRaw(target: target, options: options)
+      } else {
+        payload = try snapshotFast(target: target, options: options)
+      }
+      if let systemSurface {
+        payload.systemSurface = SystemSurfaceProvenancePayload(
+          bundleId: systemSurface.bundleId,
+          kind: systemSurface.kind.rawValue
+        )
+      }
+      setNeedsPostSnapshotInteractionDelay()
+      return Response(ok: true, data: payload)
+    } catch let failure as SnapshotCaptureFailure {
+      invalidateCachedTargetAfterSnapshotFailure()
+      return Response(
+        ok: false,
+        error: ErrorPayload(
+          code: failure.code,
+          message: failure.message,
+          hint: failure.hint
+        )
+      )
+    }
+  }
+
+  func setNeedsPostSnapshotInteractionDelay() {
+    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
+      ) {
+        self.needsPostSnapshotInteractionDelay = true
+      }
+    } catch {
+      NSLog("AGENT_DEVICE_RUNNER_POST_SNAPSHOT_DELAY_MARK_FAILED=%@", String(describing: error))
+    }
+  }
+
+  func invalidateCachedTargetAfterSnapshotFailure() {
+    applyMainOwnedSnapshotState("target_invalidation") {
+      self.invalidateCachedTarget(reason: "ax_snapshot_failure")
+    }
+  }
+}

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

@@ -57,6 +57,35 @@ struct SnapshotPhaseTimer {
   }
 }
 
+
+
+
+final class SnapshotXCTestPenaltyWarmupExemption {
+  private let lock = NSLock()
+  private var pending = false
+
+  var isPending: Bool {
+    get {
+      lock.lock()
+      defer { lock.unlock() }
+      return pending
+    }
+    set {
+      lock.lock()
+      pending = newValue
+      lock.unlock()
+    }
+  }
+
+  func consume() -> Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    let wasPending = pending
+    pending = false
+    return wasPending
+  }
+}
+
 extension RunnerTests {
   struct SnapshotBackendAttempt {
     enum Outcome {
@@ -69,11 +98,25 @@ extension RunnerTests {
 
     let outcome: Outcome
     let timing: SnapshotCaptureTiming
+
+
+
+    let tierOutcome: SnapshotTierOutcome
+
+    init(
+      outcome: Outcome,
+      timing: SnapshotCaptureTiming,
+      tierOutcome: SnapshotTierOutcome = .completed
+    ) {
+      self.outcome = outcome
+      self.timing = timing
+      self.tierOutcome = tierOutcome
+    }
   }
 
 
 
-  private static func snapshotXCTestPenaltyReason(
+  static func snapshotXCTestPenaltyReason(
     kind: SnapshotBackendKind,
     attempt: SnapshotBackendAttempt,
     slowThresholdMs: Double
@@ -84,6 +127,9 @@ extension RunnerTests {
     {
       return "\(kind.rawValue)_backend_timeout"
     }
+    if attempt.tierOutcome == .deadlineExhausted {
+      return "\(kind.rawValue)_backend_timeout"
+    }
     guard attempt.timing.acquisitionMs > slowThresholdMs else { return nil }
     return "slow_\(kind.rawValue)_capture_\(Int(attempt.timing.acquisitionMs))ms"
   }
@@ -91,6 +137,7 @@ extension RunnerTests {
   func recordXCTestSnapshotBackendAttemptIfNeeded(
     _ kind: SnapshotBackendKind,
     attempt: SnapshotBackendAttempt,
+    bundleId: String?,
     penaltySuppressed: Bool
   ) {
     guard !penaltySuppressed else { return }
@@ -102,84 +149,8 @@ extension RunnerTests {
       )
     else { return }
     penalizeSnapshotXCTestChannel(
-      bundleId: currentBundleId,
+      bundleId: bundleId,
       reason: reason
     )
   }
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

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

@@ -67,43 +67,6 @@ extension RunnerTests {
 
 
 
-  func awaitSynthesizedFirstResponderCommit(
-    app: XCUIApplication,
-    target: TextEntryTarget,
-    textBefore: String?,
-    typedText: String
-  ) -> SynthesizedTextCommitOutcome {
-    guard let textBefore, !typedText.contains("\n"), !typedText.contains("\r") else {
-      return .unobservable
-    }
-    let expectedText = textBefore + typedText
-    let waitStartedAt = Date()
-    NSLog("[DEBUG-1874] wait start expectedLen=%ld route=append", expectedText.count)
-    let ingredients = synthesizedCommitPollingIngredients(app: app, target: target, expectedText: expectedText)
-    let outcome = Self.awaitSynthesizedCommitOutcome(
-      expectedText: expectedText,
-      placeholder: ingredients.placeholder,
-      now: { Date() },
-      observe: ingredients.observe,
-      waitForNextObservation: ingredients.waitForNextObservation
-    )
-    NSLog(
-      "[DEBUG-1874] wait outcome=%@ elapsedMs=%.0f route=append",
-      String(describing: outcome),
-      waitStartedAt.timeIntervalSinceNow * -1000
-    )
-    return outcome
-  }
-
-
-
-
-
-
-
-
-
-
 
   func awaitSynthesizedReplacementCommit(
     app: XCUIApplication,
@@ -163,13 +126,6 @@ extension RunnerTests {
 
 
 
-
-
-
-
-
-
-
   private func synthesizedCommitPollingIngredients(
     app: XCUIApplication,
     target: TextEntryTarget,

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

@@ -14,15 +14,12 @@ enum RunnerAccessibilityHealth: String, Equatable {
 
 enum SynthesizedKeyboardPolicy: String, Equatable, Hashable {
   case never
-  case whenAccessibilityHealthy
   case requiredWhenAvailable
 
   func allowsProbe(accessibilityHealth: RunnerAccessibilityHealth) -> Bool {
     switch self {
     case .never:
       return false
-    case .whenAccessibilityHealthy:
-      return accessibilityHealth == .healthy
     case .requiredWhenAvailable:
       return accessibilityHealth != .unavailable
     }
@@ -63,7 +60,6 @@ struct SynthesizedCoordinateContext {
 
   let resolvedWindow: XCUIElement
   let keyboardPolicy: SynthesizedKeyboardPolicy
-  let fallbackPolicy: SynthesizedFallbackPolicy
   let accessibilityHealth: RunnerAccessibilityHealth
 
   func withReferenceFrame(_ frame: CGRect) -> SynthesizedCoordinateContext {
@@ -71,15 +67,10 @@ struct SynthesizedCoordinateContext {
       referenceFrame: frame,
       resolvedWindow: resolvedWindow,
       keyboardPolicy: keyboardPolicy,
-      fallbackPolicy: fallbackPolicy,
       accessibilityHealth: accessibilityHealth
     )
   }
 
-  var allowsXCTestCoordinateFallback: Bool {
-    fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: accessibilityHealth)
-  }
-
   var allowsKeyboardProbe: Bool {
     keyboardPolicy.allowsProbe(accessibilityHealth: accessibilityHealth)
   }
@@ -115,10 +106,22 @@ func shouldProbeCoordinateTapTextInput(xCTestChannelPenalized: Bool) -> Bool {
   !xCTestChannelPenalized
 }
 
-func sequenceHasSynthesizedCoordinateStep(_ steps: [SequenceStep]) -> Bool {
-  steps.contains { step in
-    step.synthesized == true && step.kind == "tap"
-  }
+
+func synthesizedPolicyKind(forSequenceStep step: SequenceStep) -> SynthesizedGesturePolicyKind? {
+  step.synthesized == true && step.kind == "tap" ? .coordinateTap : nil
+}
+
+
+enum SynthesizedGestureAttempt {
+  case performed(timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double))
+
+  case xctestFallback(message: String, hint: String?)
+
+  case refused(
+    timing: (gestureStartUptimeMs: Double, gestureEndUptimeMs: Double),
+    message: String,
+    hint: String?
+  )
 }
 
 extension RunnerTests {
@@ -126,11 +129,36 @@ extension RunnerTests {
     steps: [SequenceStep],
     app: XCUIApplication
   ) -> SynthesizedCoordinateContext? {
-    guard sequenceHasSynthesizedCoordinateStep(steps) else { return nil }
-    return synthesizedCoordinateContext(
-      app: app,
-      policy: synthesizedGesturePolicy(.synthesizedDrag)
+    guard let kind = steps.lazy.compactMap(synthesizedPolicyKind(forSequenceStep:)).first else {
+      return nil
+    }
+    return synthesizedCoordinateContext(app: app, policy: synthesizedGesturePolicy(kind))
+  }
+
+
+
+  func performSynthesizedGesture(
+    _ app: XCUIApplication,
+    kind: SynthesizedGesturePolicyKind,
+    context: SynthesizedCoordinateContext?,
+    synthesize: () -> RunnerInteractionOutcome
+  ) -> SynthesizedGestureAttempt {
+    let (timing, outcome) = performGesture(app, idleTimeout: false, synthesize)
+    guard case .unsupported(let message, let hint) = outcome else {
+      logSynthesizedGesturePolicyDecision(kind: kind, context: context, fallbackAttempted: false)
+      return .performed(timing: timing)
+    }
+    let fallbackAllowed = synthesizedGesturePolicy(kind).fallbackPolicy.allowsXCTestCoordinateFallback(
+      accessibilityHealth: context?.accessibilityHealth ?? runnerAccessibilityHealth
     )
+    logSynthesizedGesturePolicyDecision(
+      kind: kind,
+      context: context,
+      fallbackAttempted: fallbackAllowed
+    )
+    return fallbackAllowed
+      ? .xctestFallback(message: message, hint: hint)
+      : .refused(timing: timing, message: message, hint: hint)
   }
 
   func logSynthesizedGesturePolicyDecision(
@@ -139,104 +167,35 @@ extension RunnerTests {
     fallbackAttempted: Bool
   ) {
 #if os(iOS)
-    guard let context else {
-      NSLog(
-        "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=%@ context=unavailable fallbackAttempted=%@",
-        kind.rawValue,
-        fallbackAttempted.description
-      )
-      return
-    }
-    NSLog(
-      "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=%@ axHealth=%@ frameSource=window keyboardPolicy=%@ fallbackPolicy=%@ fallbackAllowed=%@ fallbackAttempted=%@",
-      kind.rawValue,
-      context.accessibilityHealth.rawValue,
-      context.keyboardPolicy.rawValue,
-      context.fallbackPolicy.rawValue,
-      context.allowsXCTestCoordinateFallback.description,
-      fallbackAttempted.description
+    let line = Self.synthesizedGesturePolicyLine(
+      kind: kind,
+      context: context,
+      fallbackAttempted: fallbackAttempted
     )
-#endif
-  }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
+    if lastLoggedGesturePolicyLines[kind] != line {
+      lastLoggedGesturePolicyLines[kind] = line
+      runnerMarkerWriter(line)
+    }
+#endif
+  }
 
+  static func synthesizedGesturePolicyLine(
+    kind: SynthesizedGesturePolicyKind,
+    context: SynthesizedCoordinateContext?,
+    fallbackAttempted: Bool
+  ) -> String {
+    guard let context else {
+      return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
+        + " context=unavailable fallbackAttempted=\(fallbackAttempted)"
+    }
+    let fallbackPolicy = synthesizedGesturePolicy(kind).fallbackPolicy
+    return "AGENT_DEVICE_RUNNER_SYNTHESIZED_GESTURE_POLICY kind=\(kind.rawValue)"
+      + " axHealth=\(context.accessibilityHealth.rawValue) frameSource=window"
+      + " keyboardPolicy=\(context.keyboardPolicy.rawValue)"
+      + " fallbackPolicy=\(fallbackPolicy.rawValue)"
+      + " fallbackAllowed=\(fallbackPolicy.allowsXCTestCoordinateFallback(accessibilityHealth: context.accessibilityHealth))"
+      + " fallbackAttempted=\(fallbackAttempted)"
+  }
+}