agent-device 0.21.0 → 0.21.1

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

@@ -1,8 +1,8 @@
 import XCTest
 
-// Text entry & keyboard-readiness for the runner: the focus -> type -> verify -> repair
-// pipeline, readiness polling, and field clearing. Behavior-preserving extraction from
-// RunnerTests+Interaction.swift (no logic changes) to keep that file navigable.
+
+
+
 extension RunnerTests {
   enum TextEntryFailure: String {
     case notFocused = "TEXT_INPUT_NOT_FOCUSED"
@@ -45,13 +45,13 @@ extension RunnerTests {
     static let pollInterval: TimeInterval = 0.02
     static let warmupValueTimeout: TimeInterval = 0.4
     static let verificationStabilityWindow: TimeInterval = 0.2
-    /// How long the commit wait tolerates seeing NO further progress toward the expected value.
-    /// Numerically the flat deadline this replaced, so a pipeline that delivers nothing is
-    /// condemned at exactly the same instant it always was (see `SynthesizedCommitDeadline`).
+
+
+
     static let synthesizedCommitStallTimeout: TimeInterval = 3.0
-    /// The commit wait's absolute bound, however long characters keep arriving. Sits well inside
-    /// the daemon's per-command budget (`RUNNER_COMMAND_TIMEOUT_MS`, 45s), which also has to cover
-    /// focus, clear and verification around this wait.
+
+
+
     static let synthesizedCommitCeiling: TimeInterval = 10.0
     static let synthesizedCommitPollInterval: TimeInterval = 0.2
   }
@@ -114,14 +114,14 @@ extension RunnerTests {
   }
 
   func clearTextInput(_ element: XCUIElement) {
-    // Skip the clear (delete burst + moveCaretToEnd edge-tap) ONLY when we can confirm the
-    // field is empty. Why skip: the edge-tap computes a point from the element frame, which can
-    // be stale after the field repositions on focus (e.g. the Settings search bar jumps
-    // bottom->top and reveals a "Suggestions" list) — tapping there navigates away instead of
-    // clearing; and replacing into an already-empty field is a no-op anyway.
-    // editableTextValue returns nil for secure (and unknown) fields, where we CANNOT confirm
-    // emptiness — those must still be cleared, or replace would concatenate stale + new text.
-    // So distinguish nil (clear) from "" (skip).
+
+
+
+
+
+
+
+
     if let existing = editableTextValue(for: element, treatingPlaceholderAsEmpty: true),
        existing.isEmpty {
       return

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

@@ -1,10 +1,10 @@
 import XCTest
 
-// Text-entry target acquisition: choosing the element a `type`/`fill` will address and getting
-// focus onto it — the one-shot tap witness, the post-tap stabilization, and the two
-// `focusTextInputForTextEntry` entry points the command layer calls. Whether that target is ready
-// is RunnerTests+TextEntryReadiness.swift's question, and this file asks it rather than answering
-// it.
+
+
+
+
+
 extension RunnerTests {
   func rememberTextEntryTap(_ element: XCUIElement?) {
     guard let element, isTextEntryElement(element) else {
@@ -26,8 +26,8 @@ extension RunnerTests {
     guard let witness = textEntryTapWitness else {
       return nil
     }
-    // The tap is proof for one immediately-following bare type only. Consume it before checking
-    // the element so a failed or interrupted type cannot reuse stale focus evidence.
+
+
     clearRememberedTextEntryTap()
     guard witness.matches(
       bundleId: currentBundleId,
@@ -36,16 +36,16 @@ extension RunnerTests {
       return nil
     }
     let element = witness.element
-    // XCUIElement is query-backed rather than a stable node identity. A same-identifier field
-    // introduced by app-side navigation between tap and this immediate type can therefore
-    // re-resolve here; keep the witness one-shot and fail closed on every observable identity
-    // boundary instead of using frame equality, which would reject legitimate layout changes.
+
+
+
+
     guard safely("LAST_TAPPED_TEXT_INPUT_EXISTS", false, { element.exists }) else {
       return nil
     }
-    // Keep the target scoped to the element that the preceding tap actually selected. Do not
-    // attach a refresh point: if that element disappeared, bare type must fail closed rather
-    // than rediscovering a different field or dispatching unscoped app.typeText.
+
+
+
     return TextEntryTarget(
       element: element,
       refreshPoint: nil,
@@ -69,8 +69,8 @@ extension RunnerTests {
       if let focused = focusedTextInput(app: app) {
         return TextEntryStabilization(element: focused, focusConfirmed: true)
       }
-      // focusedTextInput is intentionally nil on iOS; treat the keyboard transitioning to
-      // visible after our tap as the focus-moved signal. Don't fast-path when it was already up.
+
+
       if keyboardBecameVisible(app: app, wasVisibleAtEntry: keyboardVisibleAtEntry) {
         return TextEntryStabilization(element: latest, focusConfirmed: true)
       }
@@ -86,10 +86,10 @@ extension RunnerTests {
       if !softwareKeyboardVisible, let rememberedTarget = rememberedTextEntryTarget() {
         return rememberedTarget
       }
-      // Bare `type` targets the current first responder. On iOS we intentionally do not trust
-      // `hasKeyboardFocus`, but an already-visible software keyboard is sufficient evidence that
-      // app.typeText has a receiver; waiting the full readiness timeout cannot prove a stronger
-      // target because there is no selector/coordinate focus move to validate.
+
+
+
+
       if softwareKeyboardVisible {
         return TextEntryTarget(
           element: focusedTextInput(app: app),
@@ -121,9 +121,9 @@ extension RunnerTests {
     } else {
       _ = tapAt(app: app, x: x, y: y)
     }
-    // A visible keyboard is not enough evidence for app.typeText, because focus may still
-    // belong to a previous field. With a concrete target we type through XCUIElement.typeText,
-    // so after tapping it the iOS readiness timeout cannot prove anything stronger.
+
+
+
     if keyboardVisibleBeforeTap, let target {
       return TextEntryTarget(
         element: target,
@@ -158,8 +158,8 @@ extension RunnerTests {
     if let point {
       _ = tapAt(app: app, x: point.x, y: point.y)
     }
-    // See the coordinate-target path above: direct element typing keeps this scoped to the
-    // tapped target, while the first-character warmup and final verify still catch dropped input.
+
+
     if keyboardVisibleBeforeTap {
       return TextEntryTarget(
         element: element,
@@ -198,9 +198,9 @@ extension RunnerTests {
     return CGPoint(x: frame.midX, y: frame.midY)
   }
 
-  /// A focus-moved signal for iOS text entry, where `focusedTextInput` is intentionally nil.
-  /// The software keyboard TRANSITIONING from hidden (at entry) to visible means the field we
-  /// just tapped gained first-responder. If the keyboard was ALREADY up (e.g. back-to-back
-  /// fills into different fields), its visibility is not evidence focus moved to the new field,
-  /// so callers must keep waiting rather than typing into the previously-focused field.
+
+
+
+
+
 }

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

@@ -1,14 +1,14 @@
 import XCTest
 
-// Text-entry readiness: whether the target is actually able to receive text yet. The waits, the
-// keyboard signals they read, and the focus corroboration that ends the hardware-keyboard window.
-// RunnerTests+TextEntryFocus.swift is the only caller of the two non-private entries here; nothing
-// in this file reaches back into it.
+
+
+
+
 extension RunnerTests {
   func focusedTextInput(app: XCUIApplication) -> XCUIElement? {
 #if os(iOS)
-    // iOS focus predicates can return stale or misleading text-input matches
-    // under XCUITest, so text entry readiness is driven by tap/keyboard state.
+
+
     return nil
 #else
     return safely("FOCUSED_INPUT_QUERY") {
@@ -49,21 +49,21 @@ extension RunnerTests {
           return focused
         }
       }
-      // Fast-path on a keyboard hidden->visible transition: our tapped field gained focus, so
-      // return immediately instead of burning the full readinessTimeout (warmup-first-char echo
-      // + post-type verify/repair remain as drop safety nets). When the keyboard was ALREADY up
-      // (back-to-back fills), this isn't a focus signal — fall through to the settle/timeout so
-      // text isn't sent to the previously-focused field.
+
+
+
+
+
       if keyboardBecameVisible(app: app, wasVisibleAtEntry: keyboardVisibleAtEntry) {
         return latest
       }
       sawSoftwareKeyboard = sawSoftwareKeyboard || keyboardElementExists(app: app)
-      // A responder that takes no software keyboard (hardware keyboard connected, or a custom
-      // `inputView`) would otherwise burn the whole readinessTimeout waiting for one that is never
-      // coming. Leaving that window a bare wall-clock guess made readiness a function of ambient
-      // simulator state (#1874): on a loaded host the keyboard is merely late, and returning here
-      // handed the caller an element that had not taken focus yet. Ask the target itself instead,
-      // and re-arm rather than re-asking every poll — the query is cheap, not free.
+
+
+
+
+
+
       if !sawSoftwareKeyboard, Date() >= hardwareKeyboardFallback, let candidate = latest {
         if keyboardFocusConfirmed(app: app, element: candidate) {
           return candidate
@@ -113,23 +113,23 @@ extension RunnerTests {
     return !wasVisibleAtEntry && isKeyboardVisible(app: app)
   }
 
-  /// Positive evidence that this element — the one readiness is about to hand its caller — holds
-  /// keyboard focus. Readable even with no software keyboard on screen, which is what lets the
-  /// hardware-keyboard fallback stop guessing from a wall clock.
-  ///
-  /// This is the same app-wide predicate `focusedTextInput` refuses to trust on iOS, used the
-  /// other way round. There, the query PICKS the target, so a stale or unrelated match becomes
-  /// the field that gets typed into. Here the target is already chosen and the query only
-  /// corroborates it: at most one element holds keyboard focus, so an answer that is not this
-  /// element is a refusal, not a substitution. Every way of being wrong therefore ends as `false`
-  /// and costs the remaining readiness timeout — exactly what the wait would spend with no
-  /// fallback at all.
+
+
+
+
+
+
+
+
+
+
+
   func keyboardFocusConfirmed(app: XCUIApplication, element: XCUIElement) -> Bool {
 #if os(iOS)
     return safely("TEXT_ENTRY_FOCUS_CONFIRMED", false) {
-      // An element that no longer resolves reads as identifier "" and frame `.zero`, which would
-      // match any focused element that also reports an empty frame. Require a real frame first,
-      // so a dead handle cannot corroborate anything.
+
+
+
       let frame = element.frame
       guard !frame.isEmpty else {
         return false

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

@@ -16,4 +16,32 @@ func isCoordinateTextInputCandidate(
 }
 
 extension RunnerTests {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }

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

@@ -0,0 +1,101 @@
+import XCTest
+
+final class TextInputProbeIssues {
+  let thread = Thread.current
+  var count = 0
+}
+
+enum TextInputProbeFailure: String {
+  case recordedIssue = "text_input_probe_recorded_issue"
+  case exception = "text_input_probe_exception"
+}
+
+enum TextInputProbeOutcome {
+  case matches([XCUIElement])
+  case absent
+  case unavailable(TextInputProbeFailure)
+}
+
+extension RunnerTests {
+  func textInputAt(app: XCUIApplication, x: Double, y: Double) -> XCUIElement? {
+    textInputCandidatesAt(app: app, point: CGPoint(x: x, y: y)).first
+  }
+
+  func textInputCandidatesAt(app: XCUIApplication, point: CGPoint) -> [XCUIElement] {
+    safely("TEXT_INPUT_AT_POINT", []) {
+      queryTextInputs(app: app, point: point, shouldStop: { false })
+    }
+  }
+
+  func coordinateTapTextInputAt(app: XCUIApplication, x: Double, y: Double) -> XCUIElement? {
+    switch probeTextInputs(app: app, point: CGPoint(x: x, y: y)) {
+    case .matches(let elements):
+      return elements.first
+    case .absent:
+      return nil
+    case .unavailable:
+      return nil
+    }
+  }
+
+  func probeTextInputs(app: XCUIApplication, point: CGPoint) -> TextInputProbeOutcome {
+    precondition(Thread.isMainThread)
+    let issues = TextInputProbeIssues()
+    suppressedIssueLock.lock()
+    let previous = textInputProbeIssues
+    textInputProbeIssues = issues
+    suppressedIssueLock.unlock()
+    defer {
+      suppressedIssueLock.lock()
+      textInputProbeIssues = previous
+      suppressedIssueLock.unlock()
+    }
+    let (elements, exception) = catchingObjCException(fallback: []) {
+      queryTextInputs(app: app, point: point, shouldStop: { self.hasTextInputProbeIssues(issues) })
+    }
+    if hasTextInputProbeIssues(issues) { return .unavailable(.recordedIssue) }
+    if exception != nil { return .unavailable(.exception) }
+    return elements.isEmpty ? .absent : .matches(elements)
+  }
+
+  private func hasTextInputProbeIssues(_ scope: TextInputProbeIssues) -> Bool {
+    suppressedIssueLock.lock()
+    defer { suppressedIssueLock.unlock() }
+    return scope.count > 0
+  }
+
+  func containTextInputProbeIssue(_ issue: XCTIssue) -> Bool {
+    suppressedIssueLock.lock()
+    guard let scope = textInputProbeIssues, scope.thread === Thread.current else {
+      suppressedIssueLock.unlock()
+      return false
+    }
+    scope.count += 1
+    suppressedIssueLock.unlock()
+    NSLog("AGENT_DEVICE_RUNNER_TEXT_INPUT_PROBE_UNAVAILABLE issue=%@", issue.compactDescription)
+    return true
+  }
+
+  private func queryTextInputs(
+    app: XCUIApplication,
+    point: CGPoint,
+    shouldStop: () -> Bool
+  ) -> [XCUIElement] {
+    var candidates: [XCUIElement] = []
+    for query in [app.textFields, app.secureTextFields, app.searchFields, app.textViews] {
+      if shouldStop() { break }
+      candidates.append(contentsOf: query.allElementsBoundByIndex)
+
+
+
+
+
+
+    }
+    guard !shouldStop() else { return [] }
+    return candidates.filter { element in
+      guard !shouldStop(), element.exists else { return false }
+      return isCoordinateTextInputCandidate(enabled: element.isEnabled, frame: element.frame, point: point)
+    }.sorted(by: smallestElementFirst)
+  }
+}

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

@@ -1,7 +1,7 @@
 import XCTest
 
-// Text typing, verification, and repair. Kept separate from focus/readiness so each
-// text-entry policy remains a bounded review surface.
+
+
 extension RunnerTests {
   func typeTextReliably(
     app: XCUIApplication,
@@ -15,15 +15,15 @@ extension RunnerTests {
   ) -> TextEntryResult {
     let totalStartedAt = Date()
     guard !text.isEmpty else {
-      // Replacing a field WITH the empty string is the clear-field primitive (#2063): the typing
-      // is vacuous but the clear is not. Returning here unconditionally left the old value in
-      // place while the response reported "typed". Append (`type`) and unrepaired entry stay
-      // no-ops, which is what an empty payload means for them.
+
+
+
+
       if repairMode == .replacement {
         guard let clearTarget = resolveTextEntryElement(app: app, target: target) else {
-          // No resolvable input means no clear happened — including the synthesized
-          // first-responder route, whose target carries no element. Success here would claim a
-          // clear the runner never performed.
+
+
+
           logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: 0, mode: repairMode)
           return TextEntryResult(
             verified: nil,
@@ -34,8 +34,8 @@ extension RunnerTests {
           )
         }
         clearTextInput(clearTarget)
-        // nil means the value is unreadable (secure fields), not "not empty": leave `verified`
-        // nil there rather than reporting a mismatch the runner cannot actually observe.
+
+
         let observed = editableTextValue(for: clearTarget, treatingPlaceholderAsEmpty: true)
         logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: 0, mode: repairMode)
         return TextEntryResult(
@@ -95,9 +95,9 @@ extension RunnerTests {
       mode: repairMode
     )
 
-    // Dispatching text through XCTest without a resolved target or evidence of a focused
-    // responder records a test failure. That tears down the long-lived runner and turns a
-    // single invalid request into a restart cascade, so fail before entering that channel.
+
+
+
     guard initialTarget != nil || (activeTarget.prefersFocusedElement && isKeyboardVisible(app: app)) else {
       logTextEntryPhase(
         commandId: commandId,
@@ -145,8 +145,8 @@ extension RunnerTests {
         let textBefore = editableTextValue(for: currentTarget, treatingPlaceholderAsEmpty: true)
         switch synthesizer.enterText(app: app, text: value, replacingExistingText: false) {
         case .continueTyping:
-          // No refresh point: like the tap-witness target itself, the commit wait must observe
-          // only the element the tap selected, never rediscover a different field.
+
+
           let commit = awaitSynthesizedFirstResponderCommit(
             app: app,
             target: TextEntryTarget(
@@ -158,9 +158,9 @@ extension RunnerTests {
             textBefore: textBefore,
             typedText: value
           )
-          // The characters were posted, so the element stays on the tuple for the caller's
-          // bookkeeping; the failure is what makes the command refuse. Reporting ok here is the
-          // defect this route had — the deadline was indistinguishable from a commit.
+
+
+
           return (currentTarget, Self.textEntryFailure(forCommitOutcome: commit))
         case .fallback:
           return (nil, .synthesisUnavailable)

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

@@ -2,13 +2,13 @@ import XCTest
 import Network
 
 extension RunnerTests {
-  // MARK: - Connection Lifecycle
+
 
   func handle(connection: NWConnection) {
     receiveRequest(connection: connection, buffer: Data())
   }
 
-  // MARK: - Request Parsing
+
 
   private func receiveRequest(connection: NWConnection, buffer: Data) {
     connection.receive(minimumIncompleteLength: 1, maximumLength: 1024 * 1024) { [weak self] data, _, _, _ in
@@ -116,9 +116,9 @@ extension RunnerTests {
         completion((jsonResponse(status: 200, response: executeUptime()), false))
         return
       }
-      // Re-sends of a still-executing commandId (the daemon's transport retry loop) attach to
-      // the in-flight execution and receive its response instead of piling a second execution
-      // onto the main queue behind it (#1105 capture pileup).
+
+
+
       if attachToInFlightCommandIfNeeded(command: command, completion: completion) {
         return
       }
@@ -181,11 +181,11 @@ extension RunnerTests {
     }
   }
 
-  // MARK: - In-Flight Command Coalescing
 
-  /// Returns true when this send duplicated a still-executing commandId and was attached as a
-  /// waiter of the in-flight execution. Otherwise marks the commandId in flight and returns
-  /// false so the caller enqueues the (single) execution.
+
+
+
+
   private func attachToInFlightCommandIfNeeded(
     command: Command,
     completion: @escaping ((data: Data, shouldFinish: Bool)) -> Void
@@ -226,14 +226,52 @@ extension RunnerTests {
   }
 
 
-  // MARK: - Response Encoding
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
   private func jsonResponse(status: Int, response: Response) -> Data {
-    // Stamp the gesture-clock uptime at the END of command handling, just before the HTTP
-    // write, so the warm snapshot and recordStart responses carry the anchor for free. This
-    // runs AFTER commandJournal.finish, so journal-stored lifecycleResponseJson stays
-    // unstamped — recovered/status-replayed results carry no anchor and the daemon falls back
-    // rather than pairing a stale uptime with a much-later receipt time.
+
+
+
+
+
     let stamped =
       response.ok
       ? response.stampingCurrentUptimeMs(ProcessInfo.processInfo.systemUptime * 1000)
@@ -262,8 +300,8 @@ extension RunnerTests {
   private func finish() {
     listener?.cancel()
     listener = nil
-    // Guard against double-fulfill: coalesced shutdown sends deliver one result to
-    // multiple waiters, each of which may ask to finish.
+
+
     doneExpectation?.fulfill()
     doneExpectation = nil
   }

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

@@ -2,8 +2,8 @@ import XCTest
 
 enum RunnerInteractionOutcome {
   case performed
-  /// A capability/state gap, surfaced to the caller as an UNSUPPORTED_OPERATION error.
-  /// `hint` is an optional actionable next step (mapped to ErrorPayload.hint).
+
+
   case unsupported(message: String, hint: String?)
 }
 
@@ -19,6 +19,27 @@ enum TvRemoteButton: String {
 
 extension RunnerTests {
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   func resolveTvRemoteDoublePressDelay() -> TimeInterval {
     guard
       let raw = ProcessInfo.processInfo.environment["AGENT_DEVICE_TV_REMOTE_DOUBLE_PRESS_DELAY_MS"],
@@ -71,9 +92,9 @@ extension RunnerTests {
 #else
     let frame = element.frame
     if !frame.isEmpty {
-      // XCUIElement.tap() can fail the whole XCTest after navigation because it
-      // re-resolves the tapped element even after the app removed it. Keep the
-      // selector target semantic, then activate its resolved stable screen point.
+
+
+
       return tapAt(app: app, x: frame.midX, y: frame.midY)
     }
     return performElementTap(element)