agent-device 0.21.11 → 0.21.12

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

@@ -1,225 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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/DeviceHubPoseTests.swift

@@ -1,30 +0,0 @@
-import XCTest
-
-@testable import AgentDeviceMacOSDeviceHub
-
-final class DeviceHubPoseTests: XCTestCase {
-  func testEveryPoseNamesTheActionBarControlDeviceHubDescribes() {
-    XCTAssertEqual(DeviceHubPose(argument: "closed")?.controlDescription, "Closed")
-    XCTAssertEqual(DeviceHubPose(argument: "book")?.controlDescription, "Book")
-    XCTAssertEqual(DeviceHubPose(argument: "OPEN")?.controlDescription, "Open")
-    XCTAssertNil(DeviceHubPose(argument: "half-open"), "the helper takes Device Hub's names, not the CLI's")
-    XCTAssertEqual(Set(DeviceHubPose.allCases.map(\.controlDescription)), ["Closed", "Book", "Open"])
-  }
-
-  // Device Hub titles the window `<name> – iOS 27.1`; a simulator whose name merely starts
-  // with another's must not claim that window.
-  func testWindowTitleMatchesTheDeviceNameAsAPrefixWord() {
-    XCTAssertTrue(deviceHubWindowShows(deviceName: "iPhone Duo", title: "iPhone Duo – iOS 27.1"))
-    XCTAssertTrue(deviceHubWindowShows(deviceName: "iPhone Duo", title: "iPhone Duo"))
-    XCTAssertFalse(deviceHubWindowShows(deviceName: "iPhone Duo", title: "iPhone Duo Lab – iOS 27.1"))
-    XCTAssertFalse(deviceHubWindowShows(deviceName: "iPhone Duo", title: "bench-golden-v1 – iOS 27.0"))
-    XCTAssertFalse(deviceHubWindowShows(deviceName: "iPhone Duo", title: nil))
-  }
-
-  func testSidebarRowIsKeyedByUdid() {
-    XCTAssertEqual(
-      deviceHubDeviceRowIdentifier(udid: "4F879835-4AB3-4046-B033-5AB769209DD4"),
-      "TableRow.Device.4F879835-4AB3-4046-B033-5AB769209DD4"
-    )
-  }
-}

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

@@ -1,65 +0,0 @@
-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")
-  }
-
-}