fix(ios): recognize and answer the localized Open in launch confirmation

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerAlertLabelVocabulary.swift

@@ -37,56 +37,47 @@
   /// preferred language the app localizes into, so every preferred language takes part.
   static let system = fromSystemStrings(languages: Locale.preferredLanguages)
 
-  /// The string tables that word the system permission prompts: notifications, privacy access
-  /// (including App Tracking Transparency), and location.
-  private static let promptStringTables = [
-    ("/System/Library/PrivateFrameworks/UserNotificationsServer.framework", "Localizable"),
-    ("/System/Library/PrivateFrameworks/TCC.framework", "Localizable"),
-    ("/System/Library/Frameworks/CoreLocation.framework", "locationd")
-  ]
-
-  /// Pairs each English prompt string with the same key's value in each of `languages`. Every
-  /// table must read, or none counts: a missing table could hide the translation that makes a
-  /// label in another table claim both actions.
+  /// Pairs each English prompt string with the same key's value in each of `languages`.
   static func fromSystemStrings(languages: [String]) -> RunnerAlertLabelVocabulary {
-    // The simulated OS, taken from where this process's Foundation loaded; the simulator process
-    // would otherwise read the host's /System.
-    let foundationPath = "/System/Library/Frameworks/Foundation.framework"
-    guard let foundation = Bundle(identifier: "com.apple.Foundation")?.bundlePath, foundation.hasSuffix(foundationPath)
-    else { return unavailable(source: foundationPath, languages: languages) }
-    let root = String(foundation.dropLast(foundationPath.count))
+    composed(
+      permission: RunnerSystemPromptStrings.read(RunnerSystemPromptStrings.promptTables, languages: languages),
+      launchConfirmation: RunnerSystemPromptStrings.read([RunnerSystemPromptStrings.launchConfirmationTable], languages: languages),
+      languages: languages
+    )
+  }
+
+  /// Every permission table must read, or none of them counts: a missing table could hide the
+  /// translation that makes a label in another table claim both actions. The launch confirmation's
+  /// table is independent of them. Only its open and cancel labels are taken, so they stay when the
+  /// permission read fails, and the permission vocabulary stays whole when that table is missing.
+  static func composed(
+    permission: Result<[RunnerSystemPromptStrings], RunnerSystemPromptStrings.UnavailableSource>,
+    launchConfirmation: Result<[RunnerSystemPromptStrings], RunnerSystemPromptStrings.UnavailableSource>,
+    languages: [String]
+  ) -> RunnerAlertLabelVocabulary {
+    var tables: [RunnerSystemPromptStrings] = []
+    switch permission {
+    case .failure(let failure):
+      RunnerSystemPromptStrings.logUnavailable(failure, subsystem: "alert-vocabulary", languages: languages)
+    case .success(let read):
+      tables = read
+    }
+    switch launchConfirmation {
+    case .failure(let failure):
+      RunnerSystemPromptStrings.logUnavailable(failure, subsystem: "alert-vocabulary-launch-confirmation", languages: languages)
+    case .success(let read):
+      tables += read.map { $0.limited(to: RunnerSystemPromptStrings.launchConfirmationLabelKeys) }
+    }
     var translations: [(english: String, localized: String)] = []
-    for (path, table) in promptStringTables {
-      guard let bundle = Bundle(path: root + path),
-        let english = strings(in: bundle, table: table, localization: "en")
-      else { return unavailable(source: path, languages: languages) }
-      let localizations = Set(languages.compactMap {
-        Bundle.preferredLocalizations(from: bundle.localizations, forPreferences: [$0]).first
-      }).subtracting(["en"])
-      for localization in localizations {
-        guard let localized = strings(in: bundle, table: table, localization: localization)
-        else { return unavailable(source: "\(path) \(localization)", languages: languages) }
-        for (key, value) in english {
-          if let translation = localized[key] { translations.append((english: value, localized: translation)) }
+    for table in tables {
+      for strings in table.localized.values {
+        for (key, value) in table.english {
+          if let translation = strings[key] { translations.append((english: value, localized: translation)) }
         }
       }
     }
     return RunnerAlertLabelVocabulary(translations: translations)
   }
-
-  private static func unavailable(source: String, languages: [String]) -> RunnerAlertLabelVocabulary {
-    NSLog(
-      "AGENT_DEVICE_RUNNER_ALERT_VOCABULARY_UNAVAILABLE source=%@ languages=%@",
-      source, languages.joined(separator: ",")
-    )
-    return .english
-  }
-
-  private static func strings(in bundle: Bundle, table: String, localization: String) -> [String: String]? {
-    guard let url = bundle.url(forResource: table, withExtension: "strings", subdirectory: nil, localization: localization)
-    else { return nil }
-    return NSDictionary(contentsOf: url) as? [String: String]
-  }
 }
 #else
 extension RunnerAlertLabelVocabulary {

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerLaunchConfirmationPrompt.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+/// SpringBoard's `Open in “<App>”?` launch confirmation, recognized by the OS's own wording of its
+/// title and its two buttons. A prompt counts only when both buttons are exactly the open and
+/// cancel labels of one language, so an app alert that happens to start the same way is not it.
+struct RunnerLaunchConfirmationPrompt {
+  /// One language's wording, as SpringBoard's `SchemeApproval` strings give it.
+  struct Wording {
+    let titleFormat: String
+    let open: String
+    let cancel: String
+  }
+
+  static let unavailable = RunnerLaunchConfirmationPrompt(wordings: [])
+
+  private static let appNamePlaceholder = try! NSRegularExpression(pattern: "%(?:\\d+\\$)?(?:\\[[^\\]]*\\])?@")
+
+  private let wordings: [(title: NSRegularExpression, open: String, cancel: String)]
+
+  /// A wording whose title format has no app-name placeholder is skipped, because its pattern would
+  /// match a title with no app name. A placeholder is `%@`, a positional `%1$@`, or Apple's
+  /// bracketed object format `%[tt]@`, as Finnish words it.
+  init(wordings: [Wording]) {
+    let placeholder = Self.appNamePlaceholder
+    self.wordings = wordings.compactMap { wording in
+      let format = wording.titleFormat as NSString
+      let slots = placeholder.matches(in: wording.titleFormat, range: NSRange(location: 0, length: format.length))
+      guard !slots.isEmpty else { return nil }
+      var pattern = ""
+      var from = 0
+      for slot in slots {
+        pattern += NSRegularExpression.escapedPattern(for: format.substring(with: NSRange(location: from, length: slot.range.location - from)))
+        pattern += ".+"
+        from = slot.range.location + slot.range.length
+      }
+      pattern += NSRegularExpression.escapedPattern(for: format.substring(from: from))
+      guard let title = try? NSRegularExpression(pattern: "^\(pattern)$") else { return nil }
+      return (title, Self.normalized(wording.open), Self.normalized(wording.cancel))
+    }
+  }
+
+  func recognizes(title: String, buttons: [String]) -> Bool {
+    let title = title.trimmingCharacters(in: .whitespacesAndNewlines)
+    let titleRange = NSRange(title.startIndex..., in: title)
+    let labels = buttons.map(Self.normalized)
+    guard labels.count == 2 else { return false }
+    return wordings.contains { wording in
+      wording.title.firstMatch(in: title, range: titleRange) != nil
+        && Set(labels) == [wording.open, wording.cancel]
+    }
+  }
+
+  private static func normalized(_ label: String) -> String {
+    label.trimmingCharacters(in: .whitespacesAndNewlines)
+  }
+}
+
+#if os(iOS) && targetEnvironment(simulator)
+extension RunnerLaunchConfirmationPrompt {
+  /// English and every preferred language, read once from the OS strings. Unreadable strings
+  /// recognize nothing, so the prompt stays an unrecognized alert.
+  static let system = fromSystemStrings(languages: Locale.preferredLanguages)
+
+  static func fromSystemStrings(languages: [String]) -> RunnerLaunchConfirmationPrompt {
+    switch RunnerSystemPromptStrings.read([RunnerSystemPromptStrings.launchConfirmationTable], languages: languages) {
+    case .failure(let failure):
+      RunnerSystemPromptStrings.logUnavailable(failure, subsystem: "launch-confirmation", languages: languages)
+      return .unavailable
+    case .success(let tables):
+      guard let table = tables.first else { return .unavailable }
+      let wordings = ([table.english] + table.localized.values).compactMap { strings -> Wording? in
+        guard let title = strings["SCHEME_APPROVAL_PROMPT_TITLE_NO_SOURCE"],
+          let open = strings["SCHEME_APPROVAL_OPEN_BUTTON"],
+          let cancel = strings["SCHEME_APPROVAL_DO_NOT_OPEN_BUTTON"]
+        else { return nil }
+        return Wording(titleFormat: title, open: open, cancel: cancel)
+      }
+      return RunnerLaunchConfirmationPrompt(wordings: wordings)
+    }
+  }
+}
+#else
+extension RunnerLaunchConfirmationPrompt {
+  static let system = unavailable
+}
+#endif

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerSystemPromptStrings.swift

@@ -0,0 +1,85 @@
+import Foundation
+
+#if os(iOS) && targetEnvironment(simulator)
+/// One OS string table read in English and in each preferred language that is not English.
+struct RunnerSystemPromptStrings {
+  let english: [String: String]
+  /// The table's strings by localization, English excluded.
+  let localized: [String: [String: String]]
+
+  /// The string tables that word the system permission prompts: notifications, privacy access
+  /// (including App Tracking Transparency), and location.
+  static let promptTables = [
+    (path: "/System/Library/PrivateFrameworks/UserNotificationsServer.framework", table: "Localizable"),
+    (path: "/System/Library/PrivateFrameworks/TCC.framework", table: "Localizable"),
+    (path: "/System/Library/Frameworks/CoreLocation.framework", table: "locationd")
+  ]
+
+  /// SpringBoard's launch confirmation. It is read apart from `promptTables`, so a runtime without
+  /// it keeps the permission prompts' vocabulary.
+  static let launchConfirmationTable = (
+    path: "/System/Library/Frameworks/CoreServices.framework",
+    table: "SchemeApproval"
+  )
+
+  /// The only keys of the launch confirmation table that the alert vocabulary takes, so another key
+  /// of an undocumented table cannot join the accept or dismiss labels.
+  static let launchConfirmationLabelKeys: Set<String> = ["SCHEME_APPROVAL_OPEN_BUTTON", "SCHEME_APPROVAL_DO_NOT_OPEN_BUTTON"]
+
+  /// Reads `tables` from the simulated OS, or names the source that did not read. The simulated OS
+  /// is taken from where this process's Foundation loaded; the simulator process would otherwise
+  /// read the host's /System. A table reads in every preferred language or not at all, because a
+  /// missing translation could hide the one that makes a label claim both actions. The read fails
+  /// as a whole when any listed table fails, so pass tables that must stand or fall together.
+  static func read(
+    _ tables: [(path: String, table: String)],
+    languages: [String]
+  ) -> Result<[RunnerSystemPromptStrings], UnavailableSource> {
+    let foundationPath = "/System/Library/Frameworks/Foundation.framework"
+    guard let foundation = Bundle(identifier: "com.apple.Foundation")?.bundlePath, foundation.hasSuffix(foundationPath)
+    else { return .failure(UnavailableSource(source: foundationPath)) }
+    let root = String(foundation.dropLast(foundationPath.count))
+    var read: [RunnerSystemPromptStrings] = []
+    for (path, table) in tables {
+      guard let bundle = Bundle(path: root + path), let english = strings(in: bundle, table: table, localization: "en")
+      else { return .failure(UnavailableSource(source: path)) }
+      let localizations = Set(languages.compactMap {
+        Bundle.preferredLocalizations(from: bundle.localizations, forPreferences: [$0]).first
+      }).subtracting(["en"])
+      var localized: [String: [String: String]] = [:]
+      for localization in localizations {
+        guard let strings = strings(in: bundle, table: table, localization: localization)
+        else { return .failure(UnavailableSource(source: "\(path) \(localization)")) }
+        localized[localization] = strings
+      }
+      read.append(RunnerSystemPromptStrings(english: english, localized: localized))
+    }
+    return .success(read)
+  }
+
+  /// This table restricted to `keys`.
+  func limited(to keys: Set<String>) -> RunnerSystemPromptStrings {
+    RunnerSystemPromptStrings(
+      english: english.filter { keys.contains($0.key) },
+      localized: localized.mapValues { $0.filter { keys.contains($0.key) } }
+    )
+  }
+
+  struct UnavailableSource: Error {
+    let source: String
+  }
+
+  static func logUnavailable(_ failure: UnavailableSource, subsystem: String, languages: [String]) {
+    NSLog(
+      "AGENT_DEVICE_RUNNER_SYSTEM_PROMPT_STRINGS_UNAVAILABLE subsystem=%@ source=%@ languages=%@",
+      subsystem, failure.source, languages.joined(separator: ",")
+    )
+  }
+
+  private static func strings(in bundle: Bundle, table: String, localization: String) -> [String: String]? {
+    guard let url = bundle.url(forResource: table, withExtension: "strings", subdirectory: nil, localization: localization)
+    else { return nil }
+    return NSDictionary(contentsOf: url) as? [String: String]
+  }
+}
+#endif

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Alert.swift

@@ -137,15 +137,26 @@
       }
     }
 
+    let title = preferredAlertTitle(alert.root, buttons: alert.buttons)
+    let items = alert.buttons.map { $0.label.trimmingCharacters(in: .whitespacesAndNewlines) }
     return Response(
       ok: true,
       data: DataPayload(
-        message: preferredAlertTitle(alert.root, buttons: alert.buttons),
-        items: alert.buttons.map { $0.label.trimmingCharacters(in: .whitespacesAndNewlines) }
+        message: title,
+        items: items,
+        launchConfirmationPrompt: marksLaunchConfirmation(alert, title: title, items: items) ? true : nil
       )
     )
   }
 
+  /// The launch confirmation is SpringBoard's own modal. An app alert can carry the same wording
+  /// and buttons, and `open` accepts a marked alert, so the mark needs the SpringBoard source too.
+  func marksLaunchConfirmation(_ alert: RunnerAlert, title: String, items: [String]) -> Bool {
+    alert.source == .blockingSystemModal
+      && alert.ownerApp === springboard
+      && RunnerLaunchConfirmationPrompt.system.recognizes(title: title, buttons: items)
+  }
+
   @MainActor
   func activateAlertButton(
     _ alert: RunnerAlert,

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

@@ -445,6 +445,9 @@ struct DataPayload: Codable {
   var text: String?
   var found: Bool?
   var items: [String]?
+  /// Set on an alert read that is SpringBoard's `Open in “<App>”?` launch confirmation, in the
+  /// device's language; absent otherwise.
+  var launchConfirmationPrompt: Bool?
   var nodes: [PresentedNode]?
   var truncated: Bool?
   var qualityPayload: SnapshotQualityPayload? = nil

apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests.swift

@@ -318,6 +318,7 @@ final class RunnerTests: XCTestCase {
     listener = try Self.makeRunnerListener(port: configuration.port)
     // Reads the OS prompt strings off the alert path, so the first accept/dismiss deadline does not pay for it.
     DispatchQueue.global(qos: .utility).async { _ = RunnerAlertLabelVocabulary.system }
+    DispatchQueue.global(qos: .utility).async { _ = RunnerLaunchConfirmationPrompt.system }
     listener?.stateUpdateHandler = { [weak self] state in
       switch state {
       case .ready: