agent-device 0.21.12 → 0.21.14

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

@@ -49,24 +49,52 @@ extension RunnerTests {
 
 
 
+
+
   func captureRunnerFrame(app: XCUIApplication) -> RunnerImage? {
-#if os(iOS)
-    guard case .success(let captured) = captureObservedScreen(app: app) else {
+    switch captureRunnerFrameResult(app: app) {
+    case .success(let captured):
+      return captured.image
+    case .failure:
       return nil
     }
-    return captured.image
+  }
+
+
+
+
+
+  func captureRunnerFrameResult(
+    app: XCUIApplication
+  ) -> Result<CapturedAppScreen, RunnerAppScreenCaptureFailure> {
+#if os(iOS)
+    return captureObservedScreen(app: app)
 #else
-    var image: RunnerImage?
+    var outcome: Result<CapturedAppScreen, RunnerAppScreenCaptureFailure> = .failure(
+      .unrenderableImage
+    )
     let capture = {
-      let screenshot = XCUIScreen.main.screenshot()
-      image = screenshot.image
+      let image = XCUIScreen.main.screenshot().image
+      if let cgImage = runnerCGImage(from: image) {
+
+
+        outcome = .success(
+          CapturedAppScreen(
+            image: image,
+            displayID: 0,
+            pixelWidth: cgImage.width,
+            pixelHeight: cgImage.height,
+            pixelsPerPoint: 1
+          )
+        )
+      }
     }
     if Thread.isMainThread {
       capture()
     } else {
       DispatchQueue.main.sync(execute: capture)
     }
-    return image
+    return outcome
 #endif
   }
 
@@ -166,8 +194,17 @@ extension RunnerTests {
     currentApp = app
     currentBundleId = nil
     currentAppProcessIdentifier = nil
+    resetTargetBoundState()
+  }
+
+
+
+
+  func resetTargetBoundState() {
     clearRememberedTextEntryTap()
-    snapshotXCTestPenaltyWarmupExemptionPending = false
+    snapshotXCTestPenaltyWarmupExemption.isPending = false
+    lastLoggedFastAppGuardLine = nil
+    lastLoggedGesturePolicyLines.removeAll()
   }
 
   func invalidateCachedTarget(reason: String) {
@@ -177,8 +214,7 @@ extension RunnerTests {
     currentApp = nil
     currentBundleId = nil
     currentAppProcessIdentifier = nil
-    clearRememberedTextEntryTap()
-    snapshotXCTestPenaltyWarmupExemptionPending = false
+    resetTargetBoundState()
   }
 
   func resetTargetAfterExternalRelaunch() -> Response {
@@ -208,10 +244,10 @@ extension RunnerTests {
     )
     currentApp = candidate
     currentAppProcessIdentifier = observedProcessIdentifier
-    clearRememberedTextEntryTap()
+    resetTargetBoundState()
     clearSnapshotXCTestChannelPenalty(reason: "target_process_changed")
     clearPrivateAXAcceptedDepth(reason: "target_process_changed")
-    snapshotXCTestPenaltyWarmupExemptionPending = true
+    snapshotXCTestPenaltyWarmupExemption.isPending = true
     beginFirstInteractionStabilization()
   }
 
@@ -246,22 +282,26 @@ extension RunnerTests {
 
   func canUseFastForegroundAppGuard(
     activeApp: XCUIApplication,
-    requestedBundleId: String?,
-    command: CommandType
+    requestedBundleId: String?
   ) -> Bool {
     guard let requestedBundleId, currentBundleId == requestedBundleId, currentApp != nil else {
       return false
     }
     guard activeApp.state == .runningForeground else { return false }
-    NSLog(
-      "AGENT_DEVICE_RUNNER_FAST_APP_GUARD command=%@ bundle=%@ state=%d",
-      String(describing: command),
-      requestedBundleId,
-      activeApp.state.rawValue
-    )
+    writeFastAppGuardMarker(bundleId: requestedBundleId, state: activeApp.state)
     return true
   }
 
+  func writeFastAppGuardMarker(bundleId: String, state: XCUIApplication.State) {
+
+
+    let line = "AGENT_DEVICE_RUNNER_FAST_APP_GUARD bundle=\(bundleId) state=\(state.rawValue)"
+    if lastLoggedFastAppGuardLine != line {
+      lastLoggedFastAppGuardLine = line
+      runnerMarkerWriter(line)
+    }
+  }
+
 
 
 
@@ -276,6 +316,31 @@ extension RunnerTests {
     return foreign.count == 1 ? foreign.first : nil
   }
 
+
+
+  func notRunningReadResponse(command: Command, bundleId: String) -> Response? {
+#if os(iOS)
+    guard isReadOnlyCommand(command),
+      XCUIApplication(bundleIdentifier: bundleId).state == .notRunning
+    else { return nil }
+    NSLog(
+      "AGENT_DEVICE_RUNNER_READ_TARGET_NOT_RUNNING bundle=%@ command=%@",
+      bundleId,
+      command.command.rawValue
+    )
+    return Response(
+      ok: false,
+      error: ErrorPayload(
+        code: RunnerWireErrorCode.appNotRunning,
+        message: "app '\(bundleId)' is not running",
+        hint: "Reads do not launch the app. Relaunch it with open; if a system prompt such as a deep-link confirmation holds its launch, answer it with alert accept."
+      )
+    )
+#else
+    return nil
+#endif
+  }
+
   func activateTarget(bundleId: String, reason: String) -> XCUIApplication {
     let target = XCUIApplication(bundleIdentifier: bundleId)
     let initialState = target.state
@@ -312,8 +377,7 @@ extension RunnerTests {
     currentApp = target
     currentBundleId = bundleId
     currentAppProcessIdentifier = Self.processIdentifier(of: target)
-    clearRememberedTextEntryTap()
-    snapshotXCTestPenaltyWarmupExemptionPending = false
+    resetTargetBoundState()
     beginFirstInteractionStabilization()
     return target
   }
@@ -387,25 +451,13 @@ extension RunnerTests {
   }
 
   func shouldRetryCommand(_ command: Command) -> Bool {
-    if RunnerEnv.isTruthy("AGENT_DEVICE_RUNNER_DISABLE_READONLY_RETRY") {
-      return false
-    }
-    return isReadOnlyCommand(command)
+    isReadOnlyCommand(command)
   }
 
   func shouldRetryException(_ command: Command, message: String) -> Bool {
     guard shouldRetryCommand(command) else { return false }
-    let normalized = message.lowercased()
-    if normalized.contains("kaxerrorservernotfound") {
-      return true
-    }
-    if normalized.contains("main thread execution timed out") {
-      return true
-    }
-    if normalized.contains("timed out") && command.command == .snapshot {
-      return true
-    }
-    return false
+
+    return message.lowercased().contains("kaxerrorservernotfound")
   }
 
 
@@ -424,8 +476,7 @@ extension RunnerTests {
 
   func shouldRetryResponse(_ response: Response) -> Bool {
     guard response.ok == false else { return false }
-    guard let message = response.error?.message.lowercased() else { return false }
-    return message.contains("is not available")
+    return response.error?.retryableFailure != nil
   }
 
   func isInteractionCommand(_ command: CommandType) -> Bool {

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

@@ -12,7 +12,9 @@ import XCTest
 extension RunnerTests {
 
 
-  private final class MainThreadWorkState {
+  private final class MainThreadWorkState<T> {
+    let completed = DispatchSemaphore(value: 0)
+    var result: Result<T, Error>?
     var finished = false
     var abandoned = false
   }
@@ -62,24 +64,71 @@ extension RunnerTests {
     if Thread.isMainThread {
       return try work()
     }
-    var result: Result<T, Error>?
-    let semaphore = DispatchSemaphore(value: 0)
-    let workState = MainThreadWorkState()
+    mainThreadWorkLock.lock()
+    let state = enqueueMainThreadWorkLocked(operation, work)
+    mainThreadWorkLock.unlock()
+    return try awaitMainThreadWork(
+      state,
+      operation: operation,
+      timeout: timeout,
+      timeoutError: timeoutError,
+      onAbandoned: onAbandoned
+    )
+  }
+
+
+
+
+
+
+
+  func runMainThreadWorkIfIdle<T>(
+    _ operation: String,
+    timeout: TimeInterval,
+    timeoutError: @escaping () -> Error,
+    _ work: @escaping () throws -> T
+  ) throws -> T? {
+    if Thread.isMainThread {
+      return nil
+    }
+    mainThreadWorkLock.lock()
+    guard mainThreadWorkInFlightCount == 0 else {
+      mainThreadWorkLock.unlock()
+      return nil
+    }
+    let state = enqueueMainThreadWorkLocked(operation, work)
+    mainThreadWorkLock.unlock()
+    return try awaitMainThreadWork(
+      state,
+      operation: operation,
+      timeout: timeout,
+      timeoutError: timeoutError,
+      onAbandoned: nil
+    )
+  }
+
+  private func enqueueMainThreadWorkLocked<T>(
+    _ operation: String,
+    _ work: @escaping () throws -> T
+  ) -> MainThreadWorkState<T> {
+    let state = MainThreadWorkState<T>()
+    mainThreadWorkInFlightCount += 1
     DispatchQueue.main.async {
       do {
-        result = .success(try work())
+        state.result = .success(try work())
       } catch {
-        result = .failure(error)
+        state.result = .failure(error)
       }
       self.mainThreadWorkLock.lock()
-      let abandoned = workState.abandoned
+      self.mainThreadWorkInFlightCount -= 1
+      let abandoned = state.abandoned
       if abandoned {
         self.abandonedMainThreadWorkCount -= 1
         if self.abandonedMainThreadWorkCount == 0 {
           self.abandonedMainThreadWorkSince = nil
         }
       } else {
-        workState.finished = true
+        state.finished = true
       }
       let allDrained = abandoned && self.abandonedMainThreadWorkCount == 0
       self.mainThreadWorkLock.unlock()
@@ -89,14 +138,29 @@ extension RunnerTests {
           NSLog("AGENT_DEVICE_RUNNER_ABANDONED_WORK_DRAINED")
         }
       }
-      semaphore.signal()
+      state.completed.signal()
     }
-    let waitResult = semaphore.wait(timeout: .now() + timeout)
+    return state
+  }
+
+  private func awaitMainThreadWork<T>(
+    _ state: MainThreadWorkState<T>,
+    operation: String,
+    timeout: TimeInterval,
+    timeoutError: @escaping () -> Error,
+    onAbandoned: (() -> Void)?
+  ) throws -> T {
+    let waitResult = state.completed.wait(timeout: .now() + timeout)
     if waitResult == .timedOut {
+
+
+
+
+
       mainThreadWorkLock.lock()
-      let abandoned = !workState.finished
+      let abandoned = !state.finished
       if abandoned {
-        workState.abandoned = true
+        state.abandoned = true
         abandonedMainThreadWorkCount += 1
         if abandonedMainThreadWorkSince == nil {
           abandonedMainThreadWorkSince = Date()
@@ -110,10 +174,10 @@ extension RunnerTests {
           timeout
         )
         onAbandoned?()
+        throw timeoutError()
       }
-      throw timeoutError()
     }
-    switch result {
+    switch state.result {
     case .success(let value):
       return value
     case .failure(let error):
@@ -135,95 +199,3 @@ extension RunnerTests {
     )
   }
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

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

@@ -17,7 +17,6 @@ enum CommandType: String, Codable {
   case readText
   case snapshot
   case screenshot
-  case back
   case backInApp
   case backSystem
   case home
@@ -78,7 +77,7 @@ extension CommandType {
 
 
     case .tap, .longPress, .drag, .remotePress, .type, .swipe, .scroll, .desktopScroll,
-         .back, .backInApp, .backSystem, .rotate, .appSwitcher,
+         .backInApp, .backSystem, .rotate, .appSwitcher,
          .keyboardDismiss, .keyboardReturn, .sequence, .gesture:
       return CommandTraits(isInteraction: true, readOnly: .never, isLifecycle: false)
 
@@ -386,8 +385,30 @@ struct SnapshotQualityPayload: Codable {
   }
 }
 
+
+enum RetryableResponseFailure: Equatable {
+  case targetAppUnavailable
+}
+
 struct ErrorPayload: Codable {
   var code: String?
   let message: String
   var hint: String?
+
+
+  var retryableFailure: RetryableResponseFailure? = nil
+
+  private enum CodingKeys: String, CodingKey {
+    case code
+    case message
+    case hint
+  }
+
+  static func targetAppUnavailable(bundleId: String?) -> ErrorPayload {
+    let subject = bundleId.map { "app '\($0)'" } ?? "runner app"
+    return ErrorPayload(
+      message: "\(subject) is not available",
+      retryableFailure: .targetAppUnavailable
+    )
+  }
 }