Commit 802429c

// Alert resolution enumerates SpringBoard alerts/sheets — the same query that can grind for

// tens of seconds (#1244). Route it through the bounded dispatched path so its detection can't

// eat the whole main-thread execution watchdog like the snapshot probe used to.

if command.command == .alert {

return try executeAlertDispatched(command: command)

}

try executeDispatchedWithRecovery(command: command) {

try self.executeSnapshotDispatchedOnce(command: command)

}

}

private func executeAlertDispatched(command: Command) throws -> Response {

try executeDispatchedWithRecovery(command: command) {

try self.executeAlertDispatchedOnce(command: command)

}

}

/// Runs a dispatched command on the background transport thread with the same read-only retry and

/// XCTest-recorded-failure invalidation that `executeOnMainSafely` gives the generic path — the

/// per-command body (`perform`) supplies its own bounded main-thread work.

private func executeDispatchedWithRecovery(

command: Command,

perform: () throws -> Response

) throws -> Response {

let response = try perform()

// If the command body abandoned a still-grinding XCTest query and recovered through an

// independent backend, the recorded-failure/retry bookkeeping below would queue behind that

// query on the main thread and re-stall the command for up to the execution watchdog —

// reintroducing the very #1244 stall the recovery just avoided. Skip it while abandoned

// XCTest work is outstanding, the same policy `setNeedsPostSnapshotInteractionDelay` uses.

if hasAbandonedTreeCapture() {

NSLog(

"AGENT_DEVICE_RUNNER_DISPATCH_RECOVERY_SKIPPED_XCTEST_OCCUPIED command=%@",

command.command.rawValue

)

return response

}

private func executeAlertDispatchedOnce(command: Command) throws -> Response {

let preparation = try runMainThreadWork(

command: command,

timeout: mainThreadExecutionTimeout,

timeoutError: mainThreadExecutionTimeoutError

) {

try self.prepareActiveCommandContextSafely(command: command)

}

let activeApp: XCUIApplication

switch preparation {

case .response(let response):

return response

case .context(let context):

activeApp = context.app

}

let action = (command.action ?? "get").lowercased()

let deadline = Date().addingTimeInterval(systemModalProbeBudget)

let resolved: RunnerAlert?

do {

resolved = try boundedResolveAlert(app: activeApp, deadline: deadline)

} catch is SnapshotCaptureFailure {

// Only the probe budget timeout degrades to a bounded result; an Obj-C exception from

// detection propagates like the generic path (invalidate + surface an error).

NSLog("AGENT_DEVICE_RUNNER_ALERT_DETECTION_ABORTED")

return Response(

ok: false,

error: ErrorPayload(

code: "ALERT_DETECTION_TIMED_OUT",

message: "Detecting a blocking alert exceeded its time budget.",

hint:

"The system alert tree is slow to read on this screen. Retry, or use screenshot as visual truth and dismiss by coordinates."

)

)

}

guard let alert = resolved else {

return Response(ok: false, error: ErrorPayload(message: "alert not found"))

}

return try runMainThreadWork(

command: command,

timeout: mainThreadExecutionTimeout,

timeoutError: mainThreadExecutionTimeoutError

) {

try self.invalidatingObjCExceptions { self.handleAlert(alert, action: action) }

}

}

/// Gives a bounded dispatched command body the same Obj-C exception handling `executeOnMainSafely`

/// gives the generic path. `runMainThreadWork`'s `try` cannot catch an Obj-C exception, so an

/// unwrapped throwing XCUITest call (a stale-element `frame`/`label`, an `allElementsBoundByIndex`

/// on a torn-down alert) would escape the block and crash the runner instead of invalidating the

/// cached target and surfacing as an error.

func invalidatingObjCExceptions<T>(_ body: () -> T) throws -> T {

var result: T?

let exceptionMessage = RunnerObjCExceptionCatcher.catchException {

result = body()

}

if let exceptionMessage {

invalidateCachedTarget(reason: "objc_exception")

throw NSError(

domain: RunnerErrorDomain.exception,

code: RunnerErrorCode.objcException,

userInfo: [NSLocalizedDescriptionKey: exceptionMessage]

)

}

return result!

}

func systemModalProbeTimeoutError(slice: TimeInterval) -> () -> Error {