agent-device 0.20.10 → 0.21.1

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,16 +181,16 @@ 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
   ) -> Bool {
-    guard let commandId = normalizedInFlightCommandId(command.commandId) else { return false }
+    guard let commandId = command.commandId?.trimmedNonEmpty else { return false }
     inFlightCommandLock.lock()
     if inFlightCommandIds.contains(commandId) {
       inFlightCommandWaiters[commandId, default: []].append(completion)
@@ -213,7 +213,7 @@ extension RunnerTests {
     completion: ((data: Data, shouldFinish: Bool)) -> Void
   ) {
     var waiters: [((data: Data, shouldFinish: Bool)) -> Void] = []
-    if let commandId = normalizedInFlightCommandId(command.commandId) {
+    if let commandId = command.commandId?.trimmedNonEmpty {
       inFlightCommandLock.lock()
       inFlightCommandIds.remove(commandId)
       waiters = inFlightCommandWaiters.removeValue(forKey: commandId) ?? []
@@ -225,24 +225,53 @@ extension RunnerTests {
     }
   }
 
-  private func normalizedInFlightCommandId(_ commandId: String?) -> String? {
-    guard let trimmed = commandId?.trimmingCharacters(in: .whitespacesAndNewlines),
-      !trimmed.isEmpty
-    else {
-      return nil
-    }
-    return trimmed
-  }
 
 
-  // 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)
@@ -271,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,12 +2,12 @@ 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?)
 }
 
-enum TvRemoteButton {
+enum TvRemoteButton: String {
   case select
   case menu
   case home
@@ -18,6 +18,28 @@ enum TvRemoteButton {
 }
 
 extension RunnerTests {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   func resolveTvRemoteDoublePressDelay() -> TimeInterval {
     guard
       let raw = ProcessInfo.processInfo.environment["AGENT_DEVICE_TV_REMOTE_DOUBLE_PRESS_DELAY_MS"],
@@ -47,24 +69,8 @@ extension RunnerTests {
   }
 
   func tvRemoteButton(from raw: String?) -> TvRemoteButton? {
-    switch raw?.lowercased() {
-    case "select":
-      return .select
-    case "menu":
-      return .menu
-    case "home":
-      return .home
-    case "up":
-      return .up
-    case "down":
-      return .down
-    case "left":
-      return .left
-    case "right":
-      return .right
-    default:
-      return nil
-    }
+    guard let raw else { return nil }
+    return TvRemoteButton(rawValue: raw.lowercased())
   }
 
   func elementHasFocus(_ element: XCUIElement) -> Bool {
@@ -86,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)

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

@@ -1,9 +1,9 @@
-//
-//  RunnerTests.swift
-//  AgentDeviceRunnerUITests
-//
-//  Created by Michał Pierzchała on 30/01/2026.
-//
+
+
+
+
+
+
 
 import XCTest
 import Network
@@ -29,8 +29,8 @@ final class RunnerTests: XCTestCase {
   }
 
   static let springboardBundleId = "com.apple.springboard"
-  // SpringBoard hosts blocking system modals on iOS/visionOS; tvOS (PineBoard/HeadBoard)
-  // and macOS have no such host, so there is nothing to probe there.
+
+
   static let hasSpringBoardSystemModalHost: Bool = {
     #if os(tvOS) || os(macOS)
       return false
@@ -48,10 +48,10 @@ final class RunnerTests: XCTestCase {
   var currentApp: XCUIApplication?
   var currentBundleId: String?
   var currentAppProcessIdentifier: Int?
-  // iOS does not reliably expose hasKeyboardFocus for a bare type request, especially when
-  // hardware-keyboard input hides the software keyboard. A successful tap on a concrete text
-  // input is a scoped witness for the immediately-following bare type; lifecycle and non-text
-  // interactions clear it before it can become stale.
+
+
+
+
   var textEntryTapWitness: TextEntryTapWitness?
   let maxRequestBytes = 2 * 1024 * 1024
   let mainThreadExecutionTimeout: TimeInterval = 30
@@ -61,88 +61,133 @@ final class RunnerTests: XCTestCase {
   let firstInteractionAfterActivateDelay: TimeInterval = 0.25
   let scrollInteractionIdleTimeoutDefault: TimeInterval = 1.0
   let tvRemoteDoublePressDelayDefault: TimeInterval = 0.0
-  // Keep a periodic XCTest liveness marker in runner.log without flooding long-lived sessions.
+
   let xctestIdleKeepaliveInterval: TimeInterval = 60.0
   let minRecordingFps = 1
   let maxRecordingFps = 120
   var needsPostSnapshotInteractionDelay = false
-  var needsFirstInteractionDelay = false
+
+
+
+
+  var firstInteractionReadyUptime: TimeInterval?
   var runnerAccessibilityHealth: RunnerAccessibilityHealth = .unknown
   var activeRecording: ScreenRecorder?
   let commandJournal = RunnerCommandJournal()
-  // Coalesces duplicate transport sends of the same commandId onto the single in-flight
-  // execution instead of enqueueing them again behind it (#1105 capture pileup).
+
+
   let inFlightCommandLock = NSLock()
   var inFlightCommandIds: Set<String> = []
   var inFlightCommandWaiters: [String: [((data: Data, shouldFinish: Bool)) -> Void]] = [:]
-  // Tracks main-queue work abandoned by the execution watchdog so new main-thread commands
-  // fail fast as busy instead of queueing behind work that cannot be cancelled (#1105).
+
+
   let mainThreadWorkLock = NSLock()
   var abandonedMainThreadWorkCount = 0
   var abandonedMainThreadWorkSince: Date?
-  // Past this age the runner stops claiming "busy, retry soon" and reports itself wedged so
-  // the daemon recycles it — the only cure once the main thread is stuck for good.
+
+
   let mainThreadWedgeThreshold: TimeInterval = 120
-  // Sticky per-bundle hint: after an XCTest-backed snapshot tier ground past its slice (or a
-  // snapshot was abandoned by the watchdog), later capture plans avoid the XCTest accessibility
-  // channel when an independent recovery backend exists, or use a bounded XCTest probe when it
-  // does not, for the same screen class (#1105/#1156).
+
+
+
+
   let snapshotXCTestChannelPenaltyLock = NSLock()
   var snapshotXCTestChannelPenaltyBundleId: String?
   var snapshotXCTestChannelPenaltyUntil = Date.distantPast
   let snapshotXCTestChannelPenaltyDuration: TimeInterval = 120
   var snapshotXCTestPenaltyWarmupExemptionPending = false
-  // Sticky per-bundle hint for the private AX depth ladder: deep RN screens reject the default
-  // depth with kAXErrorIllegalArgument on EVERY capture, so once a shallower rung is accepted
-  // later captures start there instead of re-paying the rejected deep request (~300ms per
-  // capture on the Bluesky feed). Shares the penalty's lifetime model: same duration, cleared
-  // on target process change, so screens that regain deep-capture ability are re-probed.
+
+
+
+
+
   let privateAXAcceptedDepthLock = NSLock()
   var privateAXAcceptedDepthBundleId: String?
-  // PID-bound: a relaunch (external or A->B->A while inactive) changes the process, and the new
-  // tree may accept the full depth again. Any invalidation path that drops the cached PID makes
-  // the memory unmatchable, so every fresh activation re-probes the full requested depth.
+
+
+
   var privateAXAcceptedDepthProcessIdentifier: Int?
   var privateAXAcceptedDepth: Int?
   var privateAXAcceptedDepthUntil = Date.distantPast
-  // Bluesky-class screens can grind ~4-8s before an XCTest-backed snapshot tier fails; anything
-  // past this threshold marks the screen hostile so the next capture uses non-XCTest recovery.
+
+
   let snapshotXCTestSlowCaptureThreshold: TimeInterval = 3
-  // The blocking XCTest tree snapshot XPC runs on the main thread with this slice so a
-  // content-dependent grind (#1105: seconds to minutes on live Bluesky screens) cannot pin
-  // the capture plan. On timeout the XPC keeps grinding on main; while any abandoned
-  // tree capture is outstanding, plans skip XCTest-backed tiers (tree, query sweep) until the
-  // abandoned work drains.
+
+
+
+
+
   let treeCaptureLock = NSLock()
   var abandonedTreeCaptureCount = 0
   let treeCaptureSliceBudget: TimeInterval = 8
-  // Bounds the pre-plan SpringBoard system-modal probe, which can otherwise grind for tens of
-  // seconds on remote-hosted consent dialogs and bypass the plan budget (#1244).
+
+
   let systemModalProbeBudget: TimeInterval = 4
-  // Observability for the record(_:) suppression below: how many AX-broken-screen snapshot
-  // issues this session muted, so wedge investigations see the volume without grepping logs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  var textInputProbeIssues: TextInputProbeIssues?
   let suppressedIssueLock = NSLock()
   var suppressedAxSnapshotIssueCount = 0
-  let interactiveTypes: Set<XCUIElement.ElementType> = [
-    .button,
-    .cell,
-    .checkBox,
-    .collectionView,
-    .link,
-    .menuItem,
-    .picker,
-    .searchField,
-    .segmentedControl,
-    .slider,
-    .stepper,
-    .switch,
-    .tabBar,
-    .textField,
-    .secureTextField,
-    .textView,
-    .webView
-  ]
-  // Keep blocker actions narrow to avoid false positives from generic hittable containers.
+
   let actionableTypes: Set<XCUIElement.ElementType> = [
     .button,
     .cell,
@@ -152,33 +197,34 @@ final class RunnerTests: XCTestCase {
     .switch
   ]
 
-  // MARK: - XCTest Entry
+
 
   override func setUp() {
     continueAfterFailure = true
   }
 
-  /// True for the one recorded-issue class the runner deliberately mutes: an AX-server error
-  /// (`kAXError*`) inside a "Failed to get matching snapshot" fetch. The kAXError token
-  /// intentionally covers kAXErrorIllegalArgument and its sibling AX server codes (e.g.
-  /// kAXErrorCannotComplete): any AX-server rejection inside a matching-snapshot fetch is the
-  /// same capture-plan noise the plan already classifies and recovers from. The timeout
-  /// variant ("Failed to get matching snapshot: Timed out while evaluating UI query.") carries
-  /// no kAXError token and MUST keep recording — it signals a genuinely hung query, exactly
-  /// the pathology XCTEST_RECORDED_FAILURE must stay able to see.
+
+
+
+
+
+
+
+
   static func isSuppressedAxSnapshotIssueDescription(_ description: String) -> Bool {
     description.contains("Failed to get matching snapshot") && description.contains("kAXError")
   }
 
-  /// On AX-broken screens (deep RN trees, #758/#1105) XCUIApplication queries record
-  /// "Failed to get matching snapshot: ... kAXError..." issues; XCTest tears the whole test
-  /// case down once a few accumulate, killing the long-lived runner right after the command
-  /// completes and forcing a ~25s restart per capture. This override is deliberately
-  /// suite-global (all commands, not just snapshot capture): tap-triggered element queries on
-  /// the same screens record the same noise and would still tear the runner down, and command
-  /// outcomes stay honest through their own error paths — only this issue side-channel is
-  /// muted. Everything else still records (and still drives XCTEST_RECORDED_FAILURE).
+
+
+
+
+
+
+
+
   override func record(_ issue: XCTIssue) {
+    if containTextInputProbeIssue(issue) { return }
     let description = issue.compactDescription
     if Self.isSuppressedAxSnapshotIssueDescription(description) {
       suppressedIssueLock.lock()

package/dist/apple/runner/AgentDeviceRunner/RecordingScripts/RecordingExportSupport.swift

@@ -0,0 +1,111 @@
+import AVFoundation
+import Foundation
+
+
+
+
+
+enum RecordingScriptError: Error, CustomStringConvertible {
+  case invalidArgs(String)
+  case invalidTrimRange
+  case missingVideoTrack
+  case exportFailed(String)
+
+  var description: String {
+    switch self {
+    case .invalidArgs(let message):
+      return message
+    case .invalidTrimRange:
+      return "Trim start must be before the end of the recording."
+    case .missingVideoTrack:
+      return "Input video does not contain a video track."
+    case .exportFailed(let message):
+      return message
+    }
+  }
+}
+
+func recordingOptionValue(_ arguments: [String], _ nextIndex: Int, _ flag: String) throws -> String {
+  guard nextIndex < arguments.count else {
+    throw RecordingScriptError.invalidArgs("\(flag) requires a value")
+  }
+  return arguments[nextIndex]
+}
+
+func removeStaleOutput(_ outputURL: URL) throws {
+  if FileManager.default.fileExists(atPath: outputURL.path) {
+    try FileManager.default.removeItem(at: outputURL)
+  }
+}
+
+func sourceVideoTrack(of asset: AVURLAsset) throws -> AVAssetTrack {
+  guard let track = asset.tracks(withMediaType: .video).first else {
+    throw RecordingScriptError.missingVideoTrack
+  }
+  return track
+}
+
+
+
+
+
+func makeRecordingComposition(
+  asset: AVURLAsset,
+  videoTrack: AVAssetTrack,
+  timeRange: CMTimeRange
+) throws -> AVMutableComposition {
+  let composition = AVMutableComposition()
+  guard let compositionVideoTrack = composition.addMutableTrack(
+    withMediaType: .video,
+    preferredTrackID: kCMPersistentTrackID_Invalid
+  ) else {
+    throw RecordingScriptError.exportFailed("Failed to create composition video track.")
+  }
+  try compositionVideoTrack.insertTimeRange(timeRange, of: videoTrack, at: .zero)
+
+  if let sourceAudioTrack = asset.tracks(withMediaType: .audio).first,
+     let compositionAudioTrack = composition.addMutableTrack(
+       withMediaType: .audio,
+       preferredTrackID: kCMPersistentTrackID_Invalid
+     ) {
+    try? compositionAudioTrack.insertTimeRange(timeRange, of: sourceAudioTrack, at: .zero)
+  }
+  return composition
+}
+
+func makeRecordingExporter(
+  _ composition: AVAsset,
+  presetName: String,
+  outputURL: URL,
+  videoComposition: AVMutableVideoComposition? = nil
+) throws -> AVAssetExportSession {
+  guard let exporter = AVAssetExportSession(asset: composition, presetName: presetName) else {
+    throw RecordingScriptError.exportFailed("Failed to create export session.")
+  }
+  exporter.outputURL = outputURL
+  exporter.outputFileType = .mp4
+  exporter.videoComposition = videoComposition
+  exporter.shouldOptimizeForNetworkUse = true
+  return exporter
+}
+
+
+
+func runRecordingExport(
+  _ exporter: AVAssetExportSession,
+  timeoutMessage: String,
+  failureMessage: String
+) throws {
+  let semaphore = DispatchSemaphore(value: 0)
+  exporter.exportAsynchronously {
+    semaphore.signal()
+  }
+  if semaphore.wait(timeout: .now() + 120) == .timedOut {
+    exporter.cancelExport()
+    throw RecordingScriptError.exportFailed(timeoutMessage)
+  }
+
+  if exporter.status != .completed {
+    throw RecordingScriptError.exportFailed(exporter.error?.localizedDescription ?? failureMessage)
+  }
+}