agent-device 0.21.14 → 0.21.16

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

@@ -42,8 +42,16 @@ extension RunnerTests {
 #if os(iOS)
       let postStartedAt = Date()
       let result = replacingExistingText
-        ? RunnerSynthesizedTextEntry.replaceText(withApplication: app, text: text)
-        : RunnerSynthesizedTextEntry.synthesizeText(withApplication: app, text: text)
+        ? RunnerSynthesizedTextEntry.replaceText(
+          withApplication: app,
+          text: text,
+          charactersPerSecond: TextEntryTiming.synthesizedCharactersPerSecond
+        )
+        : RunnerSynthesizedTextEntry.synthesizeText(
+          withApplication: app,
+          text: text,
+          charactersPerSecond: TextEntryTiming.synthesizedCharactersPerSecond
+        )
       NSLog(
         "[DEBUG-1874] synthesize posted %d chars status=%d tookMs=%.0f",
         text.count, result.status.rawValue, postStartedAt.timeIntervalSinceNow * -1000
@@ -73,59 +81,255 @@ extension RunnerTests {
 #endif
   }
 
-  struct SynthesizedReplacementStep: Equatable {
-    let text: String
-    let replacesExistingText: Bool
+
+
+
+
+  struct SynthesizedTextPlan: Equatable {
+
+    struct Step: Equatable {
+      let characterCount: Int
+
+
+      var replacesExistingText = false
+
+
+
+
+      var pauseAfterSeconds: TimeInterval = 0
+
+      var warmsUpField = false
+
+
+      var synthesizeCallCount: Int {
+        replacesExistingText ? 2 : 1
+      }
+    }
+
+    let steps: [Step]
+
+
+
+    static func spacedSteps(
+      characterCount: Int,
+      delaySeconds: Double,
+      replacesExistingTextOnFirstPost: Bool = false
+    ) -> [Step] {
+      (0..<characterCount).map { index in
+        Step(
+          characterCount: 1,
+          replacesExistingText: replacesExistingTextOnFirstPost && index == 0,
+          pauseAfterSeconds: index + 1 < characterCount ? delaySeconds : 0
+        )
+      }
+    }
+
+
+
+    var seconds: TimeInterval {
+      steps.reduce(0) { total, step in
+        total
+          + Double(step.characterCount) * TextEntryTiming.synthesizedCharacterInterval
+          + Double(step.synthesizeCallCount) * TextEntryTiming.synthesizeCallOverhead
+          + step.pauseAfterSeconds
+      }
+    }
+
+
+
+
+    var pacesEveryCharacter: Bool {
+      steps.count > 1 && !steps.contains(where: \.warmsUpField)
+    }
   }
 
-  static func synthesizedReplacementSteps(
-    text: String,
-    delaySeconds: Double
-  ) -> [SynthesizedReplacementStep] {
-    let characters = Array(text)
-    guard delaySeconds > 0, characters.count > 1 else {
-      return [SynthesizedReplacementStep(text: text, replacesExistingText: true)]
+
+
+  static func synthesizedDeliveryIsSpaced(characterCount: Int, delaySeconds: Double) -> Bool {
+    delaySeconds > 0 && characterCount > 1
+  }
+
+
+
+
+
+
+
+
+
+  static func synthesizedTextPlan(
+    characterCount: Int,
+    delaySeconds: Double,
+    selectsExistingText: Bool,
+    peelsWarmupCharacter: Bool = false
+  ) -> SynthesizedTextPlan {
+    if synthesizedDeliveryIsSpaced(characterCount: characterCount, delaySeconds: delaySeconds) {
+      return SynthesizedTextPlan(
+        steps: SynthesizedTextPlan.spacedSteps(
+          characterCount: characterCount,
+          delaySeconds: delaySeconds,
+          replacesExistingTextOnFirstPost: selectsExistingText
+        )
+      )
     }
-    return characters.enumerated().map { index, character in
-      SynthesizedReplacementStep(
-        text: String(character),
-        replacesExistingText: index == 0
+    guard peelsWarmupCharacter && characterCount > 1 else {
+      return SynthesizedTextPlan(
+        steps: [
+          SynthesizedTextPlan.Step(
+            characterCount: characterCount,
+            replacesExistingText: selectsExistingText
+          ),
+        ]
       )
     }
+    return SynthesizedTextPlan(
+      steps: [
+        SynthesizedTextPlan.Step(
+          characterCount: 1,
+          pauseAfterSeconds: TextEntryTiming.pollInterval,
+          warmsUpField: true
+        ),
+        SynthesizedTextPlan.Step(characterCount: characterCount - 1),
+      ]
+    )
+  }
+
+
+
+  enum SynthesizedDeliveryBudget {
+    static func exceeds(_ plan: SynthesizedTextPlan) -> Bool {
+      plan.seconds > TextEntryTiming.synthesizedDeliveryCeiling
+    }
+
+
+
+
+    static func maxTextLength(delaySeconds: TimeInterval) -> Int {
+      var length = 1
+      while !exceeds(
+        synthesizedTextPlan(
+          characterCount: length + 1,
+          delaySeconds: delaySeconds,
+          selectsExistingText: true
+        )
+      ) {
+        length += 1
+      }
+      return length
+    }
+  }
+
+
+
+  enum SynthesizedStepDispatch {
+    case posted
+    case stop
+  }
+
+  struct SynthesizedPlanRun {
+    let postedCharacterCount: Int
+
+    let stoppedEarly: Bool
+  }
+
+
+
+
+
+
+
+
+
+
+
+  @MainActor
+  func runSynthesizedTextPlan(
+    _ plan: SynthesizedTextPlan,
+    text: String,
+    post: (_ characters: String, _ step: SynthesizedTextPlan.Step) -> SynthesizedStepDispatch,
+    waitAfterWarmupCharacter: (_ characters: String) -> Void,
+    didPostStep: (_ step: SynthesizedTextPlan.Step) -> Void = { _ in }
+  ) -> SynthesizedPlanRun {
+    let characters = Array(text)
+    var postedCount = 0
+    for step in plan.steps {
+      let nextCount = postedCount + step.characterCount
+      if post(String(characters[postedCount..<nextCount]), step) == .stop {
+
+        return SynthesizedPlanRun(postedCharacterCount: postedCount, stoppedEarly: true)
+      }
+      postedCount = nextCount
+      didPostStep(step)
+      if step.warmsUpField {
+        waitAfterWarmupCharacter(String(characters[postedCount - step.characterCount..<postedCount]))
+      } else if step.pauseAfterSeconds > 0 {
+        sleepFor(step.pauseAfterSeconds)
+      }
+    }
+    return SynthesizedPlanRun(postedCharacterCount: postedCount, stoppedEarly: false)
   }
 
+  @MainActor
   func runSynthesizedReplacementRoute(
     _ request: SynthesizedReplacementRequest
   ) -> SynthesizedReplacementRouteOutcome {
 #if os(iOS)
     NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder-replacement")
-    let steps = Self.synthesizedReplacementSteps(
-      text: request.text,
-      delaySeconds: request.delaySeconds
+    let plan = Self.synthesizedTextPlan(
+      characterCount: request.text.count,
+      delaySeconds: request.delaySeconds,
+      selectsExistingText: true
     )
-    for (index, step) in steps.enumerated() {
-      switch request.synthesizer.enterText(
-        app: request.app,
-        text: step.text,
-        replacingExistingText: step.replacesExistingText
-      ) {
-      case .fallback:
-        NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=verified-fallback reason=synthesis-unavailable")
-        guard let point = request.target.refreshPoint else { return .notApplicable }
-        return .fallback(
-          focusTextInputForTextEntry(app: request.app, x: point.x, y: point.y)
+    if SynthesizedDeliveryBudget.exceeds(plan) {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder-replacement "
+          + "reason=delivery-budget-refused chars=%d budgetChars=%d",
+        request.text.count,
+        SynthesizedDeliveryBudget.maxTextLength(delaySeconds: request.delaySeconds)
+      )
+      return .completed(
+        TextEntryResult(
+          verified: nil,
+          repaired: false,
+          expectedText: request.text,
+          observedText: nil,
+          textEntryRoute: "synthesized-first-responder-replacement",
+          failure: .synthesisBudgetExceeded
         )
-      case .raise(let message):
-        NSException(
-          name: NSExceptionName.internalInconsistencyException,
-          reason: message ?? "private XCTest text synthesis failed"
-        ).raise()
-      case .continueTyping:
-        break
-      }
-      if index + 1 < steps.count {
-        sleepFor(request.delaySeconds)
-      }
+      )
+    }
+
+
+    let synthesisAvailable = runSynthesizedTextPlan(
+      plan,
+      text: request.text,
+      post: { slice, step in
+        switch request.synthesizer.enterText(
+          app: request.app,
+          text: slice,
+          replacingExistingText: step.replacesExistingText
+        ) {
+        case .continueTyping:
+          return .posted
+        case .fallback:
+          return .stop
+        case .raise(let message):
+          NSException(
+            name: NSExceptionName.internalInconsistencyException,
+            reason: message ?? "private XCTest text synthesis failed"
+          ).raise()
+          return .stop
+        }
+      },
+
+      waitAfterWarmupCharacter: { _ in }
+    )
+    if synthesisAvailable.stoppedEarly {
+      NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=verified-fallback reason=synthesis-unavailable")
+      guard let point = request.target.refreshPoint else { return .notApplicable }
+      return .fallback(
+        focusTextInputForTextEntry(app: request.app, x: point.x, y: point.y)
+      )
     }
 
 

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

@@ -8,6 +8,7 @@ extension RunnerTests {
     case notFocused = "TEXT_INPUT_NOT_FOCUSED"
     case synthesisUnavailable = "TEXT_INPUT_SYNTHESIS_UNAVAILABLE"
     case commitNotObserved = "TEXT_INPUT_COMMIT_NOT_OBSERVED"
+    case synthesisBudgetExceeded = "TEXT_INPUT_SYNTHESIS_BUDGET_EXCEEDED"
 
     var message: String {
       switch self {
@@ -17,6 +18,8 @@ extension RunnerTests {
         return "Reliable text synthesis is unavailable while the software keyboard is hidden."
       case .commitNotObserved:
         return "The runner could not confirm the typed text reached the field."
+      case .synthesisBudgetExceeded:
+        return "The text is longer than one runner command can type at this pace."
       }
     }
 
@@ -27,7 +30,17 @@ extension RunnerTests {
       case .synthesisUnavailable:
         return "Show the software keyboard, then retry type."
       case .commitNotObserved:
-        return "The field may hold none, part, or all of the text. Run snapshot -i and inspect the field: if it already matches, continue; otherwise retry fill with the full text quoted and --delay-ms 80. Do not use type, which appends to whatever committed."
+        return "The field may hold none, part, or all of the text. Run snapshot -i and inspect the field: if it already matches, continue; otherwise retry fill with the full text quoted and --delay-ms \(TextEntryTiming.recoveryDelayMilliseconds). Do not use type, which appends to whatever committed."
+      case .synthesisBudgetExceeded:
+        let recoveryDelay = TextEntryTiming.recoveryDelayMilliseconds
+        let recoveryBudget = SynthesizedDeliveryBudget.maxTextLength(
+          delaySeconds: Double(recoveryDelay) / 1000
+        )
+
+
+
+
+        return "Fill at most \(SynthesizedDeliveryBudget.maxTextLength(delaySeconds: 0)) characters per command without --delay-ms and append the rest with separate type commands. --delay-ms lowers the limit: each character then gets its own synthesize call and each gap pays the delay, so \(recoveryDelay) ms fits \(recoveryBudget). This route is chosen when the accessibility channel is already degraded, so a longer timeout does not help."
       }
     }
   }
@@ -51,8 +64,40 @@ extension RunnerTests {
     static let synthesizedCommitStallTimeout: TimeInterval = 3.0
 
 
-
     static let synthesizedCommitCeiling: TimeInterval = 10.0
+
+
+    static let synthesizedReplacementFocusAllowance: TimeInterval = 2.0
+
+
+
+
+    static let synthesizedDeliveryCeiling: TimeInterval = RunnerTests.mainThreadExecutionTimeout
+      - synthesizedReplacementFocusAllowance
+      - synthesizedCommitCeiling
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    static let synthesizedCharactersPerSecond: UInt = 12
+
+    static let synthesizedCharacterInterval: TimeInterval = 1.0 / Double(synthesizedCharactersPerSecond)
+
+
+
+    static let synthesizeCallOverhead: TimeInterval = 0.15
+
+    static let recoveryDelayMilliseconds = 80
     static let synthesizedCommitPollInterval: TimeInterval = 0.2
   }
 

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

@@ -6,6 +6,7 @@ import XCTest
 
 
 extension RunnerTests {
+  @MainActor
   func rememberTextEntryTap(_ element: XCUIElement?) {
     guard let element, isTextEntryElement(element) else {
       clearRememberedTextEntryTap()
@@ -13,8 +14,8 @@ extension RunnerTests {
     }
     textEntryTapWitness = TextEntryTapWitness(
       element: element,
-      bundleId: currentBundleId,
-      processIdentifier: currentAppProcessIdentifier
+      bundleId: mainOwned.bundleId,
+      processIdentifier: mainOwned.processIdentifier
     )
   }
 
@@ -22,6 +23,7 @@ extension RunnerTests {
     textEntryTapWitness = nil
   }
 
+  @MainActor
   private func rememberedTextEntryTarget() -> TextEntryTarget? {
     guard let witness = textEntryTapWitness else {
       return nil
@@ -30,8 +32,8 @@ extension RunnerTests {
 
     clearRememberedTextEntryTap()
     guard witness.matches(
-      bundleId: currentBundleId,
-      processIdentifier: currentAppProcessIdentifier
+      bundleId: mainOwned.bundleId,
+      processIdentifier: mainOwned.processIdentifier
     ) else {
       return nil
     }
@@ -80,6 +82,7 @@ extension RunnerTests {
 #endif
   }
 
+  @MainActor
   func focusTextInputForTextEntry(app: XCUIApplication, x: Double?, y: Double?) -> TextEntryTarget {
     guard let x, let y else {
       let softwareKeyboardVisible = isKeyboardVisible(app: app)