agent-device 0.21.7 → 0.21.9

package/android/ime-helper/dist/agent-device-android-ime-helper-0.21.9.apk.sha256

@@ -0,0 +1 @@
+abf226740c34ca523708302fae272010cc2616b651b6073737c50f909f672b38  agent-device-android-ime-helper-0.21.9.apk

package/android/ime-helper/dist/{agent-device-android-ime-helper-0.21.7.manifest.json → agent-device-android-ime-helper-0.21.9.manifest.json}

@@ -1,10 +1,10 @@
 {
   "name": "android-ime-helper",
-  "version": "0.21.7",
-  "assetName": "agent-device-android-ime-helper-0.21.7.apk",
-  "sha256": "76e2409c08e5fa41a217a01d0679ea8cfa567ba8828044bb38e02f95ac512248",
+  "version": "0.21.9",
+  "assetName": "agent-device-android-ime-helper-0.21.9.apk",
+  "sha256": "abf226740c34ca523708302fae272010cc2616b651b6073737c50f909f672b38",
   "packageName": "com.callstack.agentdevice.imehelper",
-  "versionCode": 21007,
+  "versionCode": 21009,
   "serviceComponent": "com.callstack.agentdevice.imehelper/.TestInputMethodService",
   "broadcastProtocol": "android-ime-helper-v1"
 }

package/android/snapshot-helper/dist/agent-device-android-snapshot-helper-0.21.9.apk.sha256

@@ -0,0 +1 @@
+c73eed5a190579623e2c6b5baa2b3f7e760a5d41d4630e05d970826007d4ae55  agent-device-android-snapshot-helper-0.21.9.apk

package/android/snapshot-helper/dist/{agent-device-android-snapshot-helper-0.21.7.manifest.json → agent-device-android-snapshot-helper-0.21.9.manifest.json}

@@ -1,13 +1,13 @@
 {
   "name": "android-snapshot-helper",
-  "version": "0.21.7",
-  "releaseTag": "v0.21.7",
-  "assetName": "agent-device-android-snapshot-helper-0.21.7.apk",
+  "version": "0.21.9",
+  "releaseTag": "v0.21.9",
+  "assetName": "agent-device-android-snapshot-helper-0.21.9.apk",
   "apkUrl": null,
-  "sha256": "19690a5cc158aafbe0dd2bf33cd58950ef1d40ad3b52fd9e5014578ca64a7d13",
-  "checksumName": "agent-device-android-snapshot-helper-0.21.7.apk.sha256",
+  "sha256": "c73eed5a190579623e2c6b5baa2b3f7e760a5d41d4630e05d970826007d4ae55",
+  "checksumName": "agent-device-android-snapshot-helper-0.21.9.apk.sha256",
   "packageName": "com.callstack.agentdevice.snapshothelper",
-  "versionCode": 21007,
+  "versionCode": 21009,
   "instrumentationRunner": "com.callstack.agentdevice.snapshothelper/.SnapshotInstrumentation",
   "minSdk": 23,
   "targetSdk": 36,

package/apple/macos-helper/Package.swift

@@ -11,8 +11,23 @@ let package = Package(
     ),
   ],
   targets: [
+    .target(
+      name: "AgentDeviceMacOSInput"
+    ),
+    .target(
+      name: "AgentDeviceMacOSDeviceHub"
+    ),
     .executableTarget(
-      name: "AgentDeviceMacOSHelper"
+      name: "AgentDeviceMacOSHelper",
+      dependencies: ["AgentDeviceMacOSInput", "AgentDeviceMacOSDeviceHub"]
+    ),
+    .testTarget(
+      name: "AgentDeviceMacOSInputTests",
+      dependencies: ["AgentDeviceMacOSInput"]
+    ),
+    .testTarget(
+      name: "AgentDeviceMacOSDeviceHubTests",
+      dependencies: ["AgentDeviceMacOSDeviceHub"]
     ),
   ]
 )

package/apple/macos-helper/Sources/AgentDeviceMacOSDeviceHub/DeviceHubPose.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+/// The decisions the Device Hub pose press makes without a window server: which control a pose
+/// names, which window belongs to a device, and which sidebar row identifies it. They live apart
+/// from the helper executable so the tests can exercise them without an accessibility session.
+
+/// Device Hub's three pose presets for a foldable simulator, named as the helper's `--pose`
+/// argument spells them. Each maps to the accessibility description of its action-bar button.
+public enum DeviceHubPose: String, CaseIterable, Sendable {
+  case closed
+  case book
+  case open
+
+  public init?(argument: String) {
+    self.init(rawValue: argument.lowercased())
+  }
+
+  /// The `AXDescription` Device Hub gives the button for this pose.
+  public var controlDescription: String {
+    switch self {
+    case .closed: return "Closed"
+    case .book: return "Book"
+    case .open: return "Open"
+    }
+  }
+}
+
+/// Device Hub is launched through a trampoline, so LaunchServices registers it with no process
+/// identifier; the process table is matched on the executable path instead.
+public let deviceHubExecutableSuffix = "/DeviceHub.app/Contents/MacOS/DeviceHub"
+
+/// The separator Device Hub puts between the device name and the OS in a window title.
+public let deviceHubWindowTitleSeparator = " – "
+
+/// Device Hub titles a device window `<device name> – <OS> <version>`, so a window shows the
+/// device when its title is the name or the name followed by that exact separator. A bare
+/// space would also match a simulator whose name merely extends this one ("iPhone Duo Lab").
+public func deviceHubWindowShows(deviceName: String, title: String?) -> Bool {
+  guard let title else { return false }
+  return title == deviceName || title.hasPrefix(deviceName + deviceHubWindowTitleSeparator)
+}
+
+/// The accessibility identifier of the sidebar row for one simulator. The UDID is the one device
+/// identity Device Hub exposes that two simulators sharing a name cannot confuse.
+public func deviceHubDeviceRowIdentifier(udid: String) -> String {
+  return "TableRow.Device.\(udid)"
+}

package/apple/macos-helper/Sources/AgentDeviceMacOSDeviceHub/DeviceHubWindowInventory.swift

@@ -0,0 +1,65 @@
+import ApplicationServices
+
+package enum DeviceHubWindowRead {
+  case available([AXUIElement])
+  case failed(Int32)
+}
+
+package struct DeviceHubWindowCandidate {
+  package let processID: Int32
+  package let window: AXUIElement
+}
+
+package enum DeviceHubRowLookup {
+  case identified(AXUIElement, restoreSidebar: Bool)
+  case sidebarUnavailable
+  case unconfirmed
+  case timedOut
+
+  package var diagnostic: String {
+    switch self {
+    case .identified: return "identified"
+    case .sidebarUnavailable: return "sidebar-unavailable"
+    case .unconfirmed: return "row-unconfirmed"
+    case .timedOut: return "timed-out"
+    }
+  }
+}
+
+package struct DeviceHubWindowInventory {
+  package private(set) var candidates: [DeviceHubWindowCandidate] = []
+  package private(set) var emptyProcessIDs: [Int32] = []
+  package private(set) var failures: [Int32: Int32] = [:]
+  package private(set) var candidateOutcomes: [String] = []
+  package private(set) var budgetExpired = false
+
+  package init() {}
+
+  package mutating func record(processID: Int32, read: DeviceHubWindowRead) {
+    switch read {
+    case .available(let windows):
+      if windows.isEmpty { emptyProcessIDs.append(processID) }
+      candidates.append(contentsOf: windows.map { DeviceHubWindowCandidate(processID: processID, window: $0) })
+    case .failed(let status):
+      failures[processID] = status
+    }
+  }
+
+  package mutating func record(candidate: Int, outcome: DeviceHubRowLookup) {
+    candidateOutcomes.append("\(candidates[candidate].processID):\(candidate):\(outcome.diagnostic)")
+  }
+
+  package mutating func expireBudget() { budgetExpired = true }
+
+  package func processesToReopen(attempted: Set<Int32>) -> [Int32] {
+    budgetExpired ? [] : emptyProcessIDs.filter { !attempted.contains($0) }
+  }
+
+  package func failureReason(reopenFailures: [Int32: String] = [:]) -> String {
+    if !failures.isEmpty { return "device-hub-window-read-failed" }
+    if budgetExpired { return "device-hub-discovery-timeout" }
+    if !candidates.isEmpty { return "device-hub-identity-unconfirmed" }
+    if let reason = reopenFailures.sorted(by: { $0.key < $1.key }).first?.value { return reason }
+    return "device-hub-window-missing"
+  }
+}

package/apple/macos-helper/Sources/AgentDeviceMacOSHelper/DeviceHubPose.swift

@@ -0,0 +1,225 @@
+import AgentDeviceMacOSDeviceHub
+import AppKit
+import ApplicationServices
+import Darwin
+import Foundation
+
+/// How long sidebar selection and pose-control discovery may each wait before refusing a press.
+private let deviceHubSettleDeadline: TimeInterval = 8
+private let deviceHubPoll: TimeInterval = 0.25
+
+struct DeviceHubPoseResponse: Encodable {
+  let pose: String
+  let control: String
+  let windowTitle: String
+  /** Whether Device Hub had to be asked to reopen a window before the device could be selected. */
+  let reopened: Bool
+  /** Whether the window was switched to the device through its sidebar row. */
+  let selected: Bool
+}
+
+func handleDeviceHub(arguments: [String]) throws -> any Encodable {
+  guard arguments.first == "pose" else {
+    throw HelperError.invalidArgs("device-hub requires pose")
+  }
+  let rest = Array(arguments.dropFirst())
+  guard let udid = helperOptionValue(arguments: rest, name: "--udid")?
+    .trimmingCharacters(in: .whitespacesAndNewlines),
+    !udid.isEmpty
+  else {
+    throw HelperError.invalidArgs("device-hub pose requires --udid <udid>")
+  }
+  guard let deviceName = helperOptionValue(arguments: rest, name: "--device-name")?
+    .trimmingCharacters(in: .whitespacesAndNewlines),
+    !deviceName.isEmpty
+  else {
+    throw HelperError.invalidArgs("device-hub pose requires --device-name <name>")
+  }
+  guard let pose = helperOptionValue(arguments: rest, name: "--pose").flatMap(DeviceHubPose.init(argument:))
+  else {
+    throw HelperError.invalidArgs("device-hub pose requires --pose <closed|book|open>")
+  }
+  let control = pose.controlDescription
+  guard AXIsProcessTrusted() else {
+    throw HelperError.commandFailed(
+      "fold needs Accessibility permission to press the Device Hub pose control",
+      details: ["reason": "accessibility-permission", "permission": "accessibility"]
+    )
+  }
+  let discovery = try discoverDeviceHubWindow(udid: udid, deviceName: deviceName)
+  let window = discovery.window
+  defer {
+    if discovery.revealedSidebar {
+      _ = setDeviceHubSidebar(visible: false, window: window,
+        deadline: ProcessInfo.processInfo.systemUptime + 0.5)
+    }
+  }
+  let selected = try selectDevice(row: discovery.row, deviceName: deviceName, in: window)
+  let windowTitle = stringAttribute(window, attribute: kAXTitleAttribute as String) ?? ""
+  guard let button = awaitPoseButton(in: window, description: control) else {
+    throw HelperError.commandFailed(
+      "Device Hub shows no \(control) pose control for \(deviceName)",
+      details: [
+        "reason": "device-hub-pose-control-missing",
+        "windowTitle": windowTitle,
+        "control": control,
+      ]
+    )
+  }
+  let status = AXUIElementPerformAction(button, kAXPressAction as CFString)
+  guard status == .success else {
+    throw HelperError.commandFailed(
+      "Device Hub refused the \(control) pose press",
+      details: ["reason": "device-hub-press-failed", "status": "\(status.rawValue)"]
+    )
+  }
+  return SuccessEnvelope(
+    data: DeviceHubPoseResponse(
+      pose: pose.rawValue,
+      control: control,
+      windowTitle: windowTitle,
+      reopened: discovery.reopened,
+      selected: selected
+    )
+  )
+}
+
+private func windowShows(deviceName: String, _ window: AXUIElement) -> Bool {
+  return deviceHubWindowShows(
+    deviceName: deviceName,
+    title: stringAttribute(window, attribute: kAXTitleAttribute as String)
+  )
+}
+
+/// `kAEReopenApplication` is what the Dock sends when an app with no open windows is clicked, and
+/// it is the one event Device Hub answers by restoring the device window. Sent to the process
+/// directly, because LaunchServices cannot address a trampolined app by bundle identifier.
+func sendDeviceHubReopenEvent(to pid: pid_t, timeout: TimeInterval) throws {
+  let target = NSAppleEventDescriptor(processIdentifier: pid)
+  let event = NSAppleEventDescriptor(
+    eventClass: AEEventClass(kCoreEventClass),
+    eventID: AEEventID(kAEReopenApplication),
+    targetDescriptor: target,
+    returnID: AEReturnID(kAutoGenerateReturnID),
+    transactionID: AETransactionID(kAnyTransactionID)
+  )
+  do {
+    _ = try event.sendEvent(options: [.noReply], timeout: min(5, max(0.001, timeout)))
+  } catch {
+    let code = (error as NSError).code
+    throw HelperError.commandFailed(
+      "fold could not ask Device Hub to reopen its device window",
+      details: [
+        "reason": code == -1743 ? "automation-permission" : "device-hub-reopen-failed",
+        "error": String(describing: error),
+      ]
+    )
+  }
+}
+
+/// Switches the window to the device through its sidebar row, whose accessibility identifier is
+/// `TableRow.Device.<udid>` — the one place Device Hub exposes a device identity that two
+/// simulators sharing a name cannot confuse. A window already titled with the device still gets
+/// the selection, because the title alone cannot tell such twins apart.
+private func selectDevice(
+  row: AXUIElement,
+  deviceName: String,
+  in window: AXUIElement
+) throws -> Bool {
+  let deadline = ProcessInfo.processInfo.systemUptime + deviceHubSettleDeadline
+  AXUIElementSetMessagingTimeout(row, 0.25)
+  AXUIElementSetMessagingTimeout(window, 0.25)
+  let status = AXUIElementSetAttributeValue(row, kAXSelectedAttribute as CFString, kCFBooleanTrue)
+  guard status == .success || status == .cannotComplete else {
+    throw HelperError.commandFailed(
+      "Device Hub refused to select \(deviceName) in its sidebar",
+      details: ["reason": "device-hub-select-failed", "status": "\(status.rawValue)"]
+    )
+  }
+  while ProcessInfo.processInfo.systemUptime < deadline {
+    var selected: CFTypeRef?
+    if AXUIElementCopyAttributeValue(row, kAXSelectedAttribute as CFString, &selected) == .success,
+      (selected as? Bool) == true, windowShows(deviceName: deviceName, window) { return true }
+    Thread.sleep(forTimeInterval: deviceHubPoll)
+  }
+  throw HelperError.commandFailed(
+    "Device Hub did not confirm selection of \(deviceName)",
+    details: ["reason": "device-hub-select-unconfirmed", "status": "\(status.rawValue)"]
+  )
+}
+
+func deviceHubDeviceRow(udid: String, in window: AXUIElement, deadline: TimeInterval) -> AXUIElement? {
+  guard let label = findDeviceHubElement(root: window, depth: 0, deadline: deadline, where: {
+    stringAttribute($0, attribute: "AXIdentifier") == deviceHubDeviceRowIdentifier(udid: udid)
+  }) else {
+    return nil
+  }
+  var current: AXUIElement? = label
+  while let element = current, ProcessInfo.processInfo.systemUptime < deadline {
+    AXUIElementSetMessagingTimeout(element, Float(max(0.001, min(0.25, deadline - ProcessInfo.processInfo.systemUptime))))
+    if stringAttribute(element, attribute: kAXRoleAttribute as String) == "AXRow" {
+      return element
+    }
+    current = elementAttribute(element, attribute: kAXParentAttribute as String)
+  }
+  return nil
+}
+
+/// The action bar is rebuilt for the device the window shows, so right after a sidebar selection
+/// the window already carries the new title while the pose controls are still being laid out.
+/// The controls are therefore awaited, not looked up once.
+private func awaitPoseButton(in window: AXUIElement, description: String) -> AXUIElement? {
+  let deadline = ProcessInfo.processInfo.systemUptime + deviceHubSettleDeadline
+  while true {
+    if let button = poseButton(in: window, description: description, deadline: deadline) {
+      return button
+    }
+    guard ProcessInfo.processInfo.systemUptime < deadline else { return nil }
+    Thread.sleep(forTimeInterval: deviceHubPoll)
+  }
+}
+
+/// The pose controls sit in the window's action bar as `AXButton`s described by their preset
+/// name; the simulated screen inside the same window is an iOS content group whose own buttons
+/// carry app labels, never these three.
+private func poseButton(in window: AXUIElement, description: String, deadline: TimeInterval) -> AXUIElement? {
+  return findDeviceHubElement(root: window, depth: 0, deadline: deadline) {
+    stringAttribute($0, attribute: kAXRoleAttribute as String) == "AXButton"
+      && stringAttribute($0, attribute: kAXDescriptionAttribute as String) == description
+  }
+}
+
+func findDeviceHubElement(
+  root: AXUIElement,
+  depth: Int,
+  deadline: TimeInterval,
+  where matches: (AXUIElement) -> Bool
+) -> AXUIElement? {
+  let remaining = deadline - ProcessInfo.processInfo.systemUptime
+  if depth > 14 || remaining <= 0 {
+    return nil
+  }
+  AXUIElementSetMessagingTimeout(root, Float(min(0.25, remaining)))
+  for child in children(of: root) {
+    let remaining = deadline - ProcessInfo.processInfo.systemUptime
+    guard remaining > 0 else { return nil }
+    AXUIElementSetMessagingTimeout(child, Float(min(0.25, remaining)))
+    if matches(child) {
+      return child
+    }
+    if stringAttribute(child, attribute: kAXSubroleAttribute as String) == "iOSContentGroup" {
+      continue
+    }
+    if let nested = findDeviceHubElement(root: child, depth: depth + 1, deadline: deadline, where: matches) {
+      return nested
+    }
+  }
+  return nil
+}
+
+func helperOptionValue(arguments: [String], name: String) -> String? {
+  guard let index = arguments.firstIndex(of: name), arguments.indices.contains(index + 1) else {
+    return nil
+  }
+  return arguments[index + 1]
+}

package/apple/macos-helper/Sources/AgentDeviceMacOSHelper/DeviceHubSidebar.swift

@@ -0,0 +1,57 @@
+import AgentDeviceMacOSDeviceHub
+import ApplicationServices
+import Foundation
+
+func identifyDeviceHubRow(
+  udid: String,
+  candidate: DeviceHubWindowCandidate,
+  deadline: TimeInterval
+) -> DeviceHubRowLookup {
+  let now = ProcessInfo.processInfo.systemUptime
+  let visibleRowDeadline = now + max(0, deadline - now) / 3
+  if let row = deviceHubDeviceRow(udid: udid, in: candidate.window, deadline: visibleRowDeadline) {
+    return .identified(row, restoreSidebar: false)
+  }
+  let searchDeadline = deadline - 0.25
+  guard let button = deviceHubSidebarButton(visible: true, window: candidate.window, deadline: searchDeadline) else {
+    return ProcessInfo.processInfo.systemUptime >= searchDeadline ? .timedOut : .sidebarUnavailable
+  }
+  var transferCleanup = false
+  defer {
+    if !transferCleanup {
+      _ = setDeviceHubSidebar(visible: false, window: candidate.window, deadline: deadline)
+    }
+  }
+  let status = pressDeviceHubSidebarButton(button, deadline: searchDeadline)
+  guard status == .success || status == .cannotComplete else { return .unconfirmed }
+  repeat {
+    if let row = deviceHubDeviceRow(udid: udid, in: candidate.window, deadline: searchDeadline) {
+      transferCleanup = true
+      return .identified(row, restoreSidebar: true)
+    }
+    let remaining = searchDeadline - ProcessInfo.processInfo.systemUptime
+    if remaining <= 0 { return .timedOut }
+    Thread.sleep(forTimeInterval: min(0.05, remaining))
+  } while ProcessInfo.processInfo.systemUptime < searchDeadline
+  return .timedOut
+}
+
+func setDeviceHubSidebar(visible: Bool, window: AXUIElement, deadline: TimeInterval) -> Bool {
+  guard let button = deviceHubSidebarButton(visible: visible, window: window, deadline: deadline) else { return false }
+  return pressDeviceHubSidebarButton(button, deadline: deadline) == .success
+}
+
+private func deviceHubSidebarButton(visible: Bool, window: AXUIElement, deadline: TimeInterval) -> AXUIElement? {
+  let description = visible ? "Show Sidebar" : "Hide Sidebar"
+  return findDeviceHubElement(root: window, depth: 0, deadline: deadline) {
+    stringAttribute($0, attribute: kAXRoleAttribute as String) == "AXButton"
+      && stringAttribute($0, attribute: kAXDescriptionAttribute as String) == description
+  }
+}
+
+private func pressDeviceHubSidebarButton(_ button: AXUIElement, deadline: TimeInterval) -> AXError {
+  let remaining = deadline - ProcessInfo.processInfo.systemUptime
+  guard remaining > 0 else { return .cannotComplete }
+  AXUIElementSetMessagingTimeout(button, Float(min(0.1, remaining)))
+  return AXUIElementPerformAction(button, kAXPressAction as CFString)
+}

package/apple/macos-helper/Sources/AgentDeviceMacOSHelper/DeviceHubWindowDiscovery.swift

@@ -0,0 +1,108 @@
+import AgentDeviceMacOSDeviceHub
+import AppKit
+import ApplicationServices
+import Darwin
+
+struct DiscoveredDeviceHubWindow {
+  let window: AXUIElement
+  let reopened: Bool
+  let row: AXUIElement
+  let revealedSidebar: Bool
+}
+
+func discoverDeviceHubWindow(udid: String, deviceName: String) throws -> DiscoveredDeviceHubWindow {
+  let deadline = ProcessInfo.processInfo.systemUptime + 8
+  var reopened = Set<pid_t>()
+  var reopenFailures: [pid_t: String] = [:]
+  var inventory = DeviceHubWindowInventory()
+  var processIDs: [pid_t] = []
+  repeat {
+    processIDs = deviceHubProcessIdentifiers()
+    if processIDs.isEmpty {
+      throw HelperError.commandFailed(
+        "Xcode Device Hub is not running",
+        details: ["reason": "device-hub-not-running", "bundleId": "com.apple.dt.Devices"]
+      )
+    }
+    inventory = DeviceHubWindowInventory()
+    for pid in processIDs {
+      let remaining = deadline - ProcessInfo.processInfo.systemUptime
+      guard remaining > 0 else { inventory.expireBudget(); break }
+      let app = AXUIElementCreateApplication(pid)
+      AXUIElementSetMessagingTimeout(app, Float(min(0.5, remaining)))
+      var value: CFTypeRef?
+      let status = AXUIElementCopyAttributeValue(app, kAXWindowsAttribute as CFString, &value)
+      if status == .success, let windows = value as? [AXUIElement] {
+        for window in windows { AXUIElementSetMessagingTimeout(window, 0.5) }
+        inventory.record(processID: pid, read: .available(windows))
+      } else {
+        inventory.record(processID: pid, read: .failed(
+          status == .success ? AXError.illegalArgument.rawValue : status.rawValue
+        ))
+      }
+    }
+    for (index, candidate) in inventory.candidates.enumerated() {
+      let now = ProcessInfo.processInfo.systemUptime
+      guard now < deadline else { inventory.expireBudget(); break }
+      let candidateDeadline = now + (deadline - now) / Double(inventory.candidates.count - index) / 2
+      let outcome = identifyDeviceHubRow(udid: udid, candidate: candidate, deadline: candidateDeadline)
+      inventory.record(candidate: index, outcome: outcome)
+      if case .identified(let row, let restoreSidebar) = outcome {
+        return DiscoveredDeviceHubWindow(window: candidate.window,
+          reopened: reopened.contains(candidate.processID), row: row, revealedSidebar: restoreSidebar)
+      }
+    }
+    let attempted = reopened.union(reopenFailures.keys)
+    for pid in inventory.processesToReopen(attempted: attempted) {
+      guard ProcessInfo.processInfo.systemUptime < deadline else { inventory.expireBudget(); break }
+      do {
+        try sendDeviceHubReopenEvent(to: pid, timeout: deadline - ProcessInfo.processInfo.systemUptime)
+        reopened.insert(pid)
+      } catch let error as HelperError {
+        guard case .commandFailed(_, let details) = error else { throw error }
+        reopenFailures[pid] = details["reason"] ?? "device-hub-reopen-failed"
+      }
+    }
+    let remaining = deadline - ProcessInfo.processInfo.systemUptime
+    if remaining <= 0 { inventory.expireBudget(); break }
+    Thread.sleep(forTimeInterval: min(0.25, remaining))
+  } while ProcessInfo.processInfo.systemUptime < deadline
+
+  let statuses = inventory.failures.sorted { $0.key < $1.key }
+    .map { "\($0.key):\($0.value)" }.joined(separator: ",")
+  throw HelperError.commandFailed(
+    "Could not confirm a Device Hub window for the requested device",
+    details: [
+      "reason": inventory.failureReason(reopenFailures: reopenFailures),
+      "reopenFailures": reopenFailures.sorted { $0.key < $1.key }.map { "\($0.key):\($0.value)" }.joined(separator: ","),
+      "candidateOutcomes": inventory.candidateOutcomes.joined(separator: ","),
+      "udid": udid,
+      "deviceName": deviceName,
+      "processIDs": processIDs.map(String.init).joined(separator: ","),
+      "axWindowReadStatuses": statuses,
+      "hostDisplayIDs": deviceHubHostDisplays().map { String($0) }.joined(separator: ","),
+    ]
+  )
+}
+
+private func deviceHubProcessIdentifiers() -> [pid_t] {
+  let byteCount = proc_listpids(UInt32(PROC_ALL_PIDS), 0, nil, 0)
+  guard byteCount > 0 else { return [] }
+  var pids = [pid_t](repeating: 0, count: Int(byteCount) / MemoryLayout<pid_t>.size + 64)
+  let filled = proc_listpids(UInt32(PROC_ALL_PIDS), 0, &pids, Int32(pids.count * MemoryLayout<pid_t>.size))
+  guard filled > 0 else { return [] }
+  return pids.prefix(Int(filled) / MemoryLayout<pid_t>.size).filter { pid in
+    guard pid > 0 else { return false }
+    var path = [CChar](repeating: 0, count: 4096)
+    guard proc_pidpath(pid, &path, UInt32(path.count)) > 0 else { return false }
+    return String(cString: path).hasSuffix(deviceHubExecutableSuffix)
+  }.sorted()
+}
+
+private func deviceHubHostDisplays() -> [CGDirectDisplayID] {
+  var count: UInt32 = 0
+  guard CGGetActiveDisplayList(0, nil, &count) == .success else { return [] }
+  var displays = [CGDirectDisplayID](repeating: 0, count: Int(count))
+  guard CGGetActiveDisplayList(count, &displays, &count) == .success else { return [] }
+  return Array(displays.prefix(Int(count)))
+}