agent-device 0.21.8 → 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.8.manifest.json → agent-device-android-ime-helper-0.21.9.manifest.json}

@@ -1,10 +1,10 @@
 {
   "name": "android-ime-helper",
-  "version": "0.21.8",
-  "assetName": "agent-device-android-ime-helper-0.21.8.apk",
-  "sha256": "d2661c9b0183854af3266f08aa084c1e6f5171be78c468333a8166b068482327",
+  "version": "0.21.9",
+  "assetName": "agent-device-android-ime-helper-0.21.9.apk",
+  "sha256": "abf226740c34ca523708302fae272010cc2616b651b6073737c50f909f672b38",
   "packageName": "com.callstack.agentdevice.imehelper",
-  "versionCode": 21008,
+  "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.8.manifest.json → agent-device-android-snapshot-helper-0.21.9.manifest.json}

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

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

@@ -4,12 +4,7 @@ import ApplicationServices
 import Darwin
 import Foundation
 
-/// The Xcode Device Hub application. Its device windows carry an action bar whose pose controls
-/// are the only public seam onto the private channel that folds a simulator.
-private let deviceHubBundleId = "com.apple.dt.Devices"
-
-/// How long a reopen gets to restore a window, and a sidebar selection to switch the window's
-/// device, before the press is refused.
+/// 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
 
@@ -51,16 +46,15 @@ func handleDeviceHub(arguments: [String]) throws -> any Encodable {
       details: ["reason": "accessibility-permission", "permission": "accessibility"]
     )
   }
-  guard let pid = deviceHubProcessIdentifier() else {
-    throw HelperError.commandFailed(
-      "Xcode Device Hub is not running",
-      details: ["reason": "device-hub-not-running", "bundleId": deviceHubBundleId]
-    )
+  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 appElement = AXUIElementCreateApplication(pid)
-  let (window, reopened) = try deviceHubWindow(in: appElement, pid: pid, deviceName: deviceName)
-  let selected = try selectDevice(udid: udid, deviceName: deviceName, in: window, appElement: appElement)
+  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(
@@ -84,64 +78,12 @@ func handleDeviceHub(arguments: [String]) throws -> any Encodable {
       pose: pose.rawValue,
       control: control,
       windowTitle: windowTitle,
-      reopened: reopened,
+      reopened: discovery.reopened,
       selected: selected
     )
   )
 }
 
-/// Device Hub is launched through a trampoline, so LaunchServices registers it with no process
-/// identifier (`NSRunningApplication.processIdentifier` is -1) and an accessibility element built
-/// from that identifier is invalid. The process table is the only place its real pid appears.
-private func deviceHubProcessIdentifier() -> pid_t? {
-  let executableSuffix = deviceHubExecutableSuffix
-  let byteCount = proc_listpids(UInt32(PROC_ALL_PIDS), 0, nil, 0)
-  guard byteCount > 0 else { return nil }
-  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 nil }
-  var path = [CChar](repeating: 0, count: 4096)
-  for pid in pids.prefix(Int(filled) / MemoryLayout<pid_t>.size) where pid > 0 {
-    guard proc_pidpath(pid, &path, UInt32(path.count)) > 0 else { continue }
-    if String(cString: path).hasSuffix(executableSuffix) {
-      return pid
-    }
-  }
-  return nil
-}
-
-/// A device window to drive: the one already showing this device when there is one, otherwise
-/// any device window, since its sidebar can switch it to the device. A Device Hub with no window
-/// at all — a simulator booted headlessly leaves it that way — is asked to reopen one.
-private func deviceHubWindow(
-  in appElement: AXUIElement,
-  pid: pid_t,
-  deviceName: String
-) throws -> (window: AXUIElement, reopened: Bool) {
-  if let window = preferredWindow(in: appElement, deviceName: deviceName) {
-    return (window, false)
-  }
-  try sendReopenEvent(to: pid)
-  let deadline = Date().addingTimeInterval(deviceHubSettleDeadline)
-  while Date() < deadline {
-    Thread.sleep(forTimeInterval: deviceHubPoll)
-    if let window = preferredWindow(in: appElement, deviceName: deviceName) {
-      return (window, true)
-    }
-  }
-  throw HelperError.commandFailed(
-    "Device Hub shows no device window to drive",
-    details: ["reason": "device-hub-window-missing", "deviceName": deviceName]
-  )
-}
-
-private func preferredWindow(in appElement: AXUIElement, deviceName: String) -> AXUIElement? {
-  let candidates = windows(of: appElement)
-  return candidates.first { windowShows(deviceName: deviceName, $0) } ?? candidates.first
-}
-
 private func windowShows(deviceName: String, _ window: AXUIElement) -> Bool {
   return deviceHubWindowShows(
     deviceName: deviceName,
@@ -152,7 +94,7 @@ private func windowShows(deviceName: String, _ window: AXUIElement) -> Bool {
 /// `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.
-private func sendReopenEvent(to pid: pid_t) throws {
+func sendDeviceHubReopenEvent(to pid: pid_t, timeout: TimeInterval) throws {
   let target = NSAppleEventDescriptor(processIdentifier: pid)
   let event = NSAppleEventDescriptor(
     eventClass: AEEventClass(kCoreEventClass),
@@ -162,7 +104,7 @@ private func sendReopenEvent(to pid: pid_t) throws {
     transactionID: AETransactionID(kAnyTransactionID)
   )
   do {
-    _ = try event.sendEvent(options: [.noReply], timeout: 5)
+    _ = try event.sendEvent(options: [.noReply], timeout: min(5, max(0.001, timeout)))
   } catch {
     let code = (error as NSError).code
     throw HelperError.commandFailed(
@@ -178,66 +120,43 @@ private func sendReopenEvent(to pid: pid_t) throws {
 /// 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 when the row is visible, because the title alone cannot tell such twins apart.
+/// the selection, because the title alone cannot tell such twins apart.
 private func selectDevice(
-  udid: String,
+  row: AXUIElement,
   deviceName: String,
-  in window: AXUIElement,
-  appElement: AXUIElement
+  in window: AXUIElement
 ) throws -> Bool {
-  var shownSidebar = false
-  var row = deviceRow(udid: udid, in: window)
-  if row == nil, showSidebar(appElement: appElement) {
-    shownSidebar = true
-    let deadline = Date().addingTimeInterval(deviceHubSettleDeadline)
-    while row == nil, Date() < deadline {
-      Thread.sleep(forTimeInterval: deviceHubPoll)
-      row = deviceRow(udid: udid, in: window)
-    }
-  }
-  defer {
-    if shownSidebar { _ = pressMenuItem(appElement: appElement, menu: "View", item: "Hide Sidebar") }
-  }
-  guard let row else {
-    if windowShows(deviceName: deviceName, window) {
-      return false
-    }
-    throw HelperError.commandFailed(
-      "Device Hub lists no device \(udid) in its sidebar",
-      details: ["reason": "device-hub-device-missing", "udid": udid, "deviceName": deviceName]
-    )
-  }
+  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 else {
+  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)"]
     )
   }
-  let deadline = Date().addingTimeInterval(deviceHubSettleDeadline)
-  while !windowShows(deviceName: deviceName, window), Date() < deadline {
+  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)
   }
-  guard windowShows(deviceName: deviceName, window) else {
-    throw HelperError.commandFailed(
-      "Device Hub did not switch its window to \(deviceName)",
-      details: [
-        "reason": "device-hub-select-unconfirmed",
-        "windowTitle": stringAttribute(window, attribute: kAXTitleAttribute as String) ?? "",
-      ]
-    )
-  }
-  return true
+  throw HelperError.commandFailed(
+    "Device Hub did not confirm selection of \(deviceName)",
+    details: ["reason": "device-hub-select-unconfirmed", "status": "\(status.rawValue)"]
+  )
 }
 
-private func deviceRow(udid: String, in window: AXUIElement) -> AXUIElement? {
-  guard let label = findElement(root: window, depth: 0, where: {
+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 {
+  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
     }
@@ -246,36 +165,16 @@ private func deviceRow(udid: String, in window: AXUIElement) -> AXUIElement? {
   return nil
 }
 
-private func showSidebar(appElement: AXUIElement) -> Bool {
-  return pressMenuItem(appElement: appElement, menu: "View", item: "Show Sidebar")
-}
-
-private func pressMenuItem(appElement: AXUIElement, menu: String, item: String) -> Bool {
-  guard let menuBar = elementAttribute(appElement, attribute: kAXMenuBarAttribute as String) else {
-    return false
-  }
-  for menuBarItem in children(of: menuBar)
-  where stringAttribute(menuBarItem, attribute: kAXTitleAttribute as String) == menu {
-    for submenu in children(of: menuBarItem) {
-      for menuItem in children(of: submenu)
-      where stringAttribute(menuItem, attribute: kAXTitleAttribute as String) == item {
-        return AXUIElementPerformAction(menuItem, kAXPressAction as CFString) == .success
-      }
-    }
-  }
-  return false
-}
-
 /// 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 = Date().addingTimeInterval(deviceHubSettleDeadline)
+  let deadline = ProcessInfo.processInfo.systemUptime + deviceHubSettleDeadline
   while true {
-    if let button = poseButton(in: window, description: description) {
+    if let button = poseButton(in: window, description: description, deadline: deadline) {
       return button
     }
-    guard Date() < deadline else { return nil }
+    guard ProcessInfo.processInfo.systemUptime < deadline else { return nil }
     Thread.sleep(forTimeInterval: deviceHubPoll)
   }
 }
@@ -283,29 +182,35 @@ private func awaitPoseButton(in window: AXUIElement, description: String) -> AXU
 /// 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) -> AXUIElement? {
-  return findElement(root: window, depth: 0) {
+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
   }
 }
 
-private func findElement(
+func findDeviceHubElement(
   root: AXUIElement,
   depth: Int,
+  deadline: TimeInterval,
   where matches: (AXUIElement) -> Bool
 ) -> AXUIElement? {
-  if depth > 14 {
+  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 = findElement(root: child, depth: depth + 1, where: matches) {
+    if let nested = findDeviceHubElement(root: child, depth: depth + 1, deadline: deadline, where: matches) {
       return nested
     }
   }

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)))
+}

package/apple/macos-helper/Tests/AgentDeviceMacOSDeviceHubTests/DeviceHubWindowInventoryTests.swift

@@ -0,0 +1,65 @@
+import ApplicationServices
+import XCTest
+@testable import AgentDeviceMacOSDeviceHub
+
+final class DeviceHubWindowInventoryTests: XCTestCase {
+  func testLaterWindowKeepsItsProcessAndDoesNotPreventEmptyProcessReopen() {
+    var inventory = DeviceHubWindowInventory()
+    let window = AXUIElementCreateApplication(20)
+    inventory.record(processID: 10, read: .available([]))
+    inventory.record(processID: 20, read: .available([window]))
+    XCTAssertEqual(inventory.candidates.map(\.processID), [20])
+    XCTAssertTrue(CFEqual(inventory.candidates[0].window, window))
+    inventory.record(candidate: 0, outcome: .sidebarUnavailable)
+    XCTAssertEqual(inventory.processesToReopen(attempted: []), [10])
+    XCTAssertEqual(inventory.failureReason(), "device-hub-identity-unconfirmed")
+    XCTAssertEqual(inventory.candidateOutcomes, ["20:0:sidebar-unavailable"])
+  }
+
+  func testFailedReadsAreNotReopenedOrMisreportedAsMissingWindows() {
+    var inventory = DeviceHubWindowInventory()
+    inventory.record(processID: 10, read: .failed(-25204))
+    inventory.record(processID: 20, read: .available([]))
+    XCTAssertEqual(inventory.processesToReopen(attempted: []), [20])
+    XCTAssertEqual(inventory.failures, [10: -25204])
+    XCTAssertEqual(inventory.failureReason(), "device-hub-window-read-failed")
+  }
+
+  func testSuccessfulEmptyReadIsMissingAndReopenIsAttemptedOnlyOnce() {
+    var inventory = DeviceHubWindowInventory()
+    inventory.record(processID: 10, read: .available([]))
+    XCTAssertEqual(inventory.failureReason(), "device-hub-window-missing")
+    XCTAssertEqual(inventory.processesToReopen(attempted: []), [10])
+    XCTAssertEqual(inventory.processesToReopen(attempted: [10]), [])
+  }
+
+  func testSharedBudgetExhaustionStopsReopenWithoutClaimingMissingDevice() {
+    var inventory = DeviceHubWindowInventory()
+    inventory.record(processID: 10, read: .available([]))
+    inventory.expireBudget()
+    XCTAssertEqual(inventory.processesToReopen(attempted: []), [])
+    XCTAssertEqual(inventory.failureReason(), "device-hub-discovery-timeout")
+  }
+
+  func testCandidateOutcomesRetainUncertaintyAndOwningProcess() {
+    var inventory = DeviceHubWindowInventory()
+    inventory.record(processID: 10, read: .available([AXUIElementCreateApplication(10)]))
+    inventory.record(processID: 20, read: .available([AXUIElementCreateApplication(20)]))
+    inventory.record(candidate: 0, outcome: .timedOut)
+    inventory.record(candidate: 1, outcome: .unconfirmed)
+    XCTAssertEqual(inventory.candidateOutcomes, ["10:0:timed-out", "20:1:row-unconfirmed"])
+    XCTAssertEqual(inventory.failureReason(), "device-hub-identity-unconfirmed")
+  }
+  func testUnrelatedReopenFailureDoesNotMaskCandidateUncertainty() {
+    var inventory = DeviceHubWindowInventory()
+    inventory.record(processID: 10, read: .available([]))
+    let failures: [Int32: String] = [10: "automation-permission"]
+    XCTAssertEqual(inventory.failureReason(reopenFailures: failures), "automation-permission")
+    inventory.record(processID: 20, read: .available([AXUIElementCreateApplication(20)]))
+    inventory.record(candidate: 0, outcome: .timedOut)
+    XCTAssertEqual(inventory.failureReason(reopenFailures: failures), "device-hub-identity-unconfirmed")
+    inventory.expireBudget()
+    XCTAssertEqual(inventory.failureReason(reopenFailures: failures), "device-hub-discovery-timeout")
+  }
+
+}

package/dist/apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/AgentDeviceRunnerUITests-Bridging-Header.h

@@ -2,3 +2,4 @@
 #import "RunnerAXSnapshotBridge.h"
 #import "RunnerSynthesizedGesture.h"
 #import "RunnerSynthesizedTextEntry.h"
+#import "RunnerXCTestEventBridge.h"