agent-device 0.21.3 → 0.21.4

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

@@ -0,0 +1,229 @@
+import XCTest
+
+
+
+
+
+
+
+
+
+
+extension RunnerTests {
+
+
+  private final class MainThreadWorkState {
+    var finished = false
+    var abandoned = false
+  }
+
+  enum MainThreadBusyState {
+    case idle
+    case busy(abandonedForSeconds: TimeInterval)
+    case wedged(abandonedForSeconds: TimeInterval)
+
+
+
+
+    var reportsMainThreadBusy: Bool {
+      if case .idle = self { return false }
+      return true
+    }
+  }
+
+  func currentMainThreadBusyState() -> MainThreadBusyState {
+    mainThreadWorkLock.lock()
+    defer { mainThreadWorkLock.unlock() }
+    guard abandonedMainThreadWorkCount > 0 else { return .idle }
+    let abandonedFor = abandonedMainThreadWorkSince.map { Date().timeIntervalSince($0) } ?? 0
+    if abandonedFor > mainThreadWedgeThreshold {
+      return .wedged(abandonedForSeconds: abandonedFor)
+    }
+    return .busy(abandonedForSeconds: abandonedFor)
+  }
+
+  func hasAbandonedMainThreadWork() -> Bool {
+    mainThreadWorkLock.lock()
+    defer { mainThreadWorkLock.unlock() }
+    return abandonedMainThreadWorkCount > 0
+  }
+
+
+
+
+
+  func runMainThreadWork<T>(
+    _ operation: String,
+    timeout: TimeInterval,
+    timeoutError: @escaping () -> Error,
+    onAbandoned: (() -> Void)? = nil,
+    _ work: @escaping () throws -> T
+  ) throws -> T {
+    if Thread.isMainThread {
+      return try work()
+    }
+    var result: Result<T, Error>?
+    let semaphore = DispatchSemaphore(value: 0)
+    let workState = MainThreadWorkState()
+    DispatchQueue.main.async {
+      do {
+        result = .success(try work())
+      } catch {
+        result = .failure(error)
+      }
+      self.mainThreadWorkLock.lock()
+      let abandoned = workState.abandoned
+      if abandoned {
+        self.abandonedMainThreadWorkCount -= 1
+        if self.abandonedMainThreadWorkCount == 0 {
+          self.abandonedMainThreadWorkSince = nil
+        }
+      } else {
+        workState.finished = true
+      }
+      let allDrained = abandoned && self.abandonedMainThreadWorkCount == 0
+      self.mainThreadWorkLock.unlock()
+      if abandoned {
+        NSLog("AGENT_DEVICE_RUNNER_MAIN_THREAD_WORK_DRAINED operation=%@", operation)
+        if allDrained {
+          NSLog("AGENT_DEVICE_RUNNER_ABANDONED_WORK_DRAINED")
+        }
+      }
+      semaphore.signal()
+    }
+    let waitResult = semaphore.wait(timeout: .now() + timeout)
+    if waitResult == .timedOut {
+      mainThreadWorkLock.lock()
+      let abandoned = !workState.finished
+      if abandoned {
+        workState.abandoned = true
+        abandonedMainThreadWorkCount += 1
+        if abandonedMainThreadWorkSince == nil {
+          abandonedMainThreadWorkSince = Date()
+        }
+      }
+      mainThreadWorkLock.unlock()
+      if abandoned {
+        NSLog(
+          "AGENT_DEVICE_RUNNER_MAIN_THREAD_WORK_ABANDONED operation=%@ slice=%.1f",
+          operation,
+          timeout
+        )
+        onAbandoned?()
+      }
+      throw timeoutError()
+    }
+    switch result {
+    case .success(let value):
+      return value
+    case .failure(let error):
+      throw error
+    case .none:
+      throw NSError(
+        domain: RunnerErrorDomain.general,
+        code: RunnerErrorCode.noResponseFromMainThread,
+        userInfo: [NSLocalizedDescriptionKey: "no response from main thread"]
+      )
+    }
+  }
+
+  func mainThreadExecutionTimeoutError() -> Error {
+    NSError(
+      domain: RunnerErrorDomain.general,
+      code: RunnerErrorCode.mainThreadExecutionTimedOut,
+      userInfo: [NSLocalizedDescriptionKey: "main thread execution timed out"]
+    )
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -229,6 +229,16 @@ extension Response {
     payload.currentUptimeMs = value
     return Response(ok: ok, data: payload, error: error)
   }
+
+
+
+
+  func stampingCurrentMainThreadBusy(_ value: Bool) -> Response {
+    guard ok else { return self }
+    var payload = data ?? DataPayload()
+    payload.runnerMainThreadBusy = value
+    return Response(ok: ok, data: payload, error: error)
+  }
 }
 
 struct DataPayload: Codable {
@@ -276,6 +286,11 @@ struct DataPayload: Codable {
   var textEntryRoute: String?
   var runnerFatal: Bool?
   var runnerFatalReason: String?
+
+
+
+
+  var runnerMainThreadBusy: Bool?
   var completedSteps: Int?
   var failedStepIndex: Int?
   var sequenceResults: [SequenceStepResult]?

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

@@ -321,6 +321,7 @@ extension RunnerTests {
     let startedAt = Date()
     do {
       return try runMainThreadWork(
+        "system_modal_probe",
         timeout: slice,
         timeoutError: {
           SnapshotCaptureFailure(
@@ -330,16 +331,10 @@ extension RunnerTests {
           )
         },
         onAbandoned: {
-          self.retainAbandonedXCTestChannelWork()
-          NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_TIMEOUT slice=%.1f", slice)
           self.penalizeSnapshotXCTestChannel(
             bundleId: self.currentBundleId,
             reason: "system_modal_probe_timeout"
           )
-        },
-        onDrained: {
-          self.releaseAbandonedXCTestChannelWork()
-          NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_DRAINED")
         }
       ) {
         probe(probeDeadline)
@@ -788,8 +783,6 @@ extension RunnerTests {
 
 
 
-
-
 
 
 
@@ -839,6 +832,7 @@ extension RunnerTests {
     treeCaptureSliceBudgetOverride: TimeInterval? = nil
   ) throws -> SnapshotTraversalContext? {
     let viewport = try runMainThreadWork(
+      "snapshot_viewport",
       timeout: min(1.0, max(0.1, captureDeadline.timeIntervalSinceNow)),
       timeoutError: snapshotMainThreadTimeoutError("preparing tree snapshot")
     ) {
@@ -860,25 +854,6 @@ extension RunnerTests {
 
   static let xCTestSnapshotTimeoutCode = "IOS_TREE_CAPTURE_TIMEOUT"
 
-  func hasAbandonedTreeCapture() -> Bool {
-    treeCaptureLock.lock()
-    defer { treeCaptureLock.unlock() }
-    return abandonedTreeCaptureCount > 0
-  }
-
-
-
-  func retainAbandonedXCTestChannelWork() {
-    treeCaptureLock.lock()
-    abandonedTreeCaptureCount += 1
-    treeCaptureLock.unlock()
-  }
-
-  func releaseAbandonedXCTestChannelWork() {
-    treeCaptureLock.lock()
-    abandonedTreeCaptureCount -= 1
-    treeCaptureLock.unlock()
-  }
 
 
 
@@ -893,20 +868,9 @@ extension RunnerTests {
       return try captureSnapshotRoot(element)
     }
     return try runMainThreadWork(
+      "tree_capture",
       timeout: sliceSeconds,
-      timeoutError: treeCaptureTimeoutError(sliceSeconds: sliceSeconds),
-      onAbandoned: {
-        self.retainAbandonedXCTestChannelWork()
-        NSLog("AGENT_DEVICE_RUNNER_TREE_CAPTURE_SLICE_TIMEOUT slice=%.1f", sliceSeconds)
-        self.penalizeSnapshotXCTestChannel(
-          bundleId: self.currentBundleId,
-          reason: "tree_capture_slice_timeout"
-        )
-      },
-      onDrained: {
-        self.releaseAbandonedXCTestChannelWork()
-        NSLog("AGENT_DEVICE_RUNNER_TREE_CAPTURE_DRAINED")
-      }
+      timeoutError: treeCaptureTimeoutError(sliceSeconds: sliceSeconds)
     ) {
       try self.captureSnapshotRoot(element)
     }

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

@@ -248,8 +248,8 @@ extension RunnerTests {
     )
   }
 
-  func shouldSkipSnapshotBackendForAbandonedTreeCapture(_ kind: SnapshotBackendKind) -> Bool {
-    kind.usesXCTestAccessibilityChannel && hasAbandonedTreeCapture()
+  func shouldSkipSnapshotBackendForAbandonedMainThreadWork(_ kind: SnapshotBackendKind) -> Bool {
+    kind.usesXCTestAccessibilityChannel && hasAbandonedMainThreadWork()
   }
 
 
@@ -316,11 +316,11 @@ extension RunnerTests {
       }
 
 
-      if shouldSkipSnapshotBackendForAbandonedTreeCapture(kind) {
+      if shouldSkipSnapshotBackendForAbandonedMainThreadWork(kind) {
         NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_TIER_SKIPPED_XCTEST_OCCUPIED tier=%@", kind.rawValue)
         if firstFailure == nil {
           firstFailure = (
-            "the XCTest capture channel is occupied by an abandoned tree capture",
+            "the XCTest capture channel is occupied by abandoned main-thread work",
             "budget"
           )
         }
@@ -431,6 +431,7 @@ extension RunnerTests {
             return nil
           }
           return try self.runMainThreadWork(
+            "tree_processing",
             timeout: min(self.treeCaptureSliceBudget, max(0.5, deadline.timeIntervalSinceNow)),
             timeoutError: self.snapshotMainThreadTimeoutError("processing tree snapshot")
           ) {
@@ -440,6 +441,7 @@ extension RunnerTests {
           }
         case .querySweep:
           return try self.runMainThreadWork(
+            "query_sweep",
             timeout: min(Self.flatInteractiveFallbackBudget, max(0.1, deadline.timeIntervalSinceNow)),
             timeoutError: self.snapshotMainThreadTimeoutError("running query-sweep snapshot")
           ) {
@@ -1169,42 +1171,6 @@ extension RunnerTests {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 

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

@@ -152,14 +152,7 @@ extension RunnerTests {
           self.deliverCommandResult(
             command: command,
             result: (
-              self.jsonResponse(
-                status: 500,
-                response: self.errorResponse(
-                  code: "COMMAND_FAILED",
-                  message: error.localizedDescription,
-                  hint: "Check the runner log for XCTest details, then retry after the app is foregrounded if this was a timeout or activation failure."
-                )
-              ),
+              self.jsonResponse(status: 500, response: self.commandFailedResponse(from: error)),
               false
             ),
             completion: completion
@@ -274,7 +267,9 @@ extension RunnerTests {
 
     let stamped =
       response.ok
-      ? response.stampingCurrentUptimeMs(ProcessInfo.processInfo.systemUptime * 1000)
+      ? response
+        .stampingCurrentUptimeMs(ProcessInfo.processInfo.systemUptime * 1000)
+        .stampingCurrentMainThreadBusy(currentMainThreadBusyState().reportsMainThreadBusy)
       : response
     let encoder = JSONEncoder()
     let body = (try? encoder.encode(stamped)).flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
@@ -285,6 +280,32 @@ extension RunnerTests {
     Response(ok: false, error: ErrorPayload(code: code, message: message, hint: hint))
   }
 
+
+
+
+
+  func commandFailedResponse(from error: Error) -> Response {
+    let nsError = error as NSError
+    if nsError.domain == RunnerErrorDomain.general,
+      nsError.code == RunnerErrorCode.mainThreadExecutionTimedOut
+    {
+      return Response(
+        ok: false,
+        error: ErrorPayload(
+          code: RunnerWireErrorCode.mainThreadTimeout,
+          message: nsError.localizedDescription,
+          hint:
+            "The runner abandoned this command's main-thread work past its execution watchdog and it is still draining. Wait and retry, or use a screenshot and interact by coordinates."
+        )
+      )
+    }
+    return errorResponse(
+      code: "COMMAND_FAILED",
+      message: error.localizedDescription,
+      hint: "Check the runner log for XCTest details, then retry after the app is foregrounded if this was a timeout or activation failure."
+    )
+  }
+
   private func httpResponse(status: Int, body: String) -> Data {
     let headers = [
       "HTTP/1.1 \(status) OK",

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

@@ -28,6 +28,13 @@ final class RunnerTests: XCTestCase {
     static let objcException = 1
   }
 
+
+
+
+  enum RunnerWireErrorCode {
+    static let mainThreadTimeout = "MAIN_THREAD_TIMEOUT"
+  }
+
   static let springboardBundleId = "com.apple.springboard"
 
 
@@ -59,7 +66,7 @@ final class RunnerTests: XCTestCase {
   let retryCooldown: TimeInterval = 0.2
   let postSnapshotInteractionDelay: TimeInterval = 0.2
   let firstInteractionAfterActivateDelay: TimeInterval = 0.25
-  let scrollInteractionIdleTimeoutDefault: TimeInterval = 1.0
+  let interactionIdleTimeoutDefault: TimeInterval = 1.0
   let tvRemoteDoublePressDelayDefault: TimeInterval = 0.0
 
   let xctestIdleKeepaliveInterval: TimeInterval = 60.0
@@ -81,6 +88,8 @@ final class RunnerTests: XCTestCase {
   var inFlightCommandWaiters: [String: [((data: Data, shouldFinish: Bool)) -> Void]] = [:]
 
 
+
+
   let mainThreadWorkLock = NSLock()
   var abandonedMainThreadWorkCount = 0
   var abandonedMainThreadWorkSince: Date?
@@ -115,10 +124,6 @@ final class RunnerTests: XCTestCase {
 
 
 
-
-
-  let treeCaptureLock = NSLock()
-  var abandonedTreeCaptureCount = 0
   let treeCaptureSliceBudget: TimeInterval = 8
 
 
@@ -210,10 +215,20 @@ final class RunnerTests: XCTestCase {
 
 
 
+  static let axServerRejectionFetchWordings = [
+    "Failed to get matching snapshot",
+    "Failed to resolve query"
+  ]
+
+
+
+
+
 
 
   static func isSuppressedAxSnapshotIssueDescription(_ description: String) -> Bool {
-    description.contains("Failed to get matching snapshot") && description.contains("kAXError")
+    guard description.contains("kAXError") else { return false }
+    return axServerRejectionFetchWordings.contains { description.contains($0) }
   }
 
 
@@ -224,6 +239,7 @@ final class RunnerTests: XCTestCase {
 
 
 
+
   override func record(_ issue: XCTIssue) {
     if containTextInputProbeIssue(issue) { return }
     let description = issue.compactDescription