modern concurrency

src/IMessage/Sources/IMDatabaseTestBench/TestBench.swift

@@ -22,7 +22,7 @@ struct TestBench: AsyncParsableCommand {
 
     static let configuration = CommandConfiguration(
         abstract: "Exercise functionality in IMDatabase.",
-        subcommands: [Watch.self, Messages.self, Chats.self, UnreadBenchmark.self, FSEventsCommand.self, TestIdleAware.self, ClosestSelectable.self],
+        subcommands: [Watch.self, Messages.self, Chats.self, UnreadBenchmark.self, FSEventsCommand.self, ClosestSelectable.self],
         )
 
     mutating func run() async throws {}
@@ -430,54 +430,3 @@ extension TestBench {
         }
     }
 }
-
-// MARK: - Idle Aware
-
-extension TestBench {
-    struct TestIdleAware: AsyncParsableCommand {
-        static let configuration = CommandConfiguration(
-            commandName: "test-idle-aware",
-            abstract: "Tests the idle aware queue."
-        )
-        @OptionGroup var options: TestBench.Options
-
-        mutating func run() async throws {
-            bootstrap(logLevel: options.logLevel)
-
-            let queue = PassivelyAwareDispatchQueue(label: "test", idleDelay: 0.1)
-
-            queue.setIdleCallback { info in
-                print("*** IDLE! *** [0.1s] <\(info)>")
-                Thread.sleep(forTimeInterval: 0.1)
-            }
-
-            queue.async {
-                print("1. [1s]")
-                Thread.sleep(forTimeInterval: 1)
-            }
-            queue.async {
-                print("2. [0.5s]")
-                Thread.sleep(forTimeInterval: 0.5)
-            }
-            queue.async {
-                print("3. [0.25s]")
-                Thread.sleep(forTimeInterval: 0.25)
-            }
-
-            Task {
-                while true {
-                    let ms = Int.random(in: 500...4000)
-                    try! await Task.sleep(nanoseconds: UInt64(1_000_000 * ms))
-
-                    queue.async {
-                        let cost = Double.random(in: 0.5...1)
-                        print("r. [\(cost)s]")
-                        Thread.sleep(forTimeInterval: cost)
-                    }
-                }
-            }
-
-            await Task.never()
-        }
-    }
-}

src/IMessage/Sources/IMessage/Defaults.swift

@@ -21,7 +21,7 @@ enum DefaultsKeys {
     /** forces a specific coordinator (`eclipsing` or `spaces`), only checked once */
     static let coordinator = "BEEPWindowCoordinator"
 
-    /** whether to respect calls to `onThreadSelected`/`watchThreadActivity` */
+    /** whether to respect calls to `onThreadSelected` for thread activity observation */
     static let watchThreadActivity = "BEEPWatchThreadActivity"
     /** whether to continuously poll "activity status" (typing indicator, dnd banner) */
     static let pollActivityStatus = "BEEPPollActivityStatus"

src/IMessage/Sources/IMessage/Extensions.swift

@@ -1,4 +1,5 @@
 import AppKit
+import Combine
 import IMessageCore
 
 extension NSApplication {
@@ -14,20 +15,25 @@ extension NSApplication {
 }
 
 extension NSRunningApplication {
-    func waitForLaunch(interval: TimeInterval = 0.05, timeout seconds: TimeInterval = 5) throws {
-        let start = Date()
-        while !self.isFinishedLaunching {
-            Log.default.notice("sleeping \(interval)s for \(String(describing: self.localizedName)) to finish launching")
-            Thread.sleep(forTimeInterval: interval)
-            if self.isTerminated {
-                throw ErrorMessage("\(String(describing: self.localizedName)) terminated")
-            }
-            if start.timeIntervalSinceNow < -seconds {
-                Log.default.notice("assuming \(String(describing: self.localizedName)) has launched") // sometimes this gets stuck in an infinite loop
-                break
+    func waitForLaunch(timeout seconds: TimeInterval = 5) async throws {
+        var cancellable: AnyCancellable?
+        _ = cancellable
+
+        return try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            if isFinishedLaunching {
+                continuation.resume()
+            } else {
+                cancellable = self.publisher(for: \.isFinishedLaunching, options: [.initial, .new])
+                    .filter { $0 } // we only care about isFinishedLaunching = true
+                    .first()
+                    .timeout(.seconds(seconds), scheduler: DispatchQueue.global())
+                    .sink { _ in
+                        continuation.resume()
+                    } receiveValue: { _ in
+
+                    }
             }
         }
-        Thread.sleep(forTimeInterval: 0.01)
     }
 }
 
@@ -60,6 +66,7 @@ extension NSRect {
     /// primary display, the space used by Accessibility window positions and
     /// CGWindow bounds). The flip is about the primary display's height, so it is
     /// its own inverse and is correct regardless of which display the rect is on.
+    @MainActor
     func flippedBetweenCocoaAndScreenSpace() -> NSRect {
         guard let primaryHeight = NSScreen.screens.first?.frame.height else { return self }
         return NSRect(x: minX, y: primaryHeight - maxY, width: width, height: height)

src/IMessage/Sources/IMessage/IMessageHost.swift

@@ -127,7 +127,7 @@ public enum IMessageHost {
 
     public static func disableMessagesNotifications() async throws {
         try await Task.detached(priority: .background) {
-            _ = try PromptAutomation.disableNotificationsForApp(named: "Messages")
+            _ = try await PromptAutomation.disableNotificationsForApp(named: "Messages")
             Defaults.playSoundEffects = false
         }.value
     }

src/IMessage/Sources/IMessage/KeyPresser.swift

@@ -6,105 +6,110 @@ import Logging
 
 private let log = Logger(imessageLabel: "key-presser")
 
-// TODO: refactor
 class KeyPresser {
     let pid: pid_t
+    private let postKeyEvents: (CGKeyCode, CGEventFlags?) throws -> Void
+    private let keyCodeForCharacter: (Character) -> UInt16?
 
-    init(pid: pid_t) {
+    init(
+        pid: pid_t,
+        postKeyEvents: ((CGKeyCode, CGEventFlags?) throws -> Void)? = nil,
+        keyCodeForCharacter: ((Character) -> UInt16?)? = nil
+    ) {
         self.pid = pid
+        self.postKeyEvents = postKeyEvents ?? { key, flags in
+            try Self.post(key: key, flags: flags, to: pid)
+        }
+        self.keyCodeForCharacter = keyCodeForCharacter ?? { KeyMap.shared[$0] }
     }
 
     static let src = CGEventSource(stateID: .hidSystemState)
 
-    private func perform(onMainThread: Bool, _ action: () throws -> Void) rethrows {
+    private func perform<T>(onMainThread: Bool, _ action: () throws -> T) rethrows -> T {
         guard onMainThread, !Thread.isMainThread else {
-            try action()
-            return
+            return try action()
         }
         log.debug("dispatching simulated keypress to main thread (queueName=\(__dispatch_queue_get_label(nil)))")
-        try DispatchQueue.main.sync {
+        return try DispatchQueue.main.sync {
             try action()
         }
-        return
     }
 
-    private func post(key: CGKeyCode, flags: CGEventFlags? = nil) throws {
+    private static func post(key: CGKeyCode, flags: CGEventFlags? = nil, to pid: pid_t) throws {
         log.debug("sending simulated keypress (code=\(key))")
         for keyDown in [true, false] {
             log.debug("simulated keypress phase (code=\(key), down=\(keyDown))")
             // all events will not be posted for _some_ users if `keyboardEventSource` is nil
             let ev = try CGEvent(keyboardEventSource: Self.src, virtualKey: key, keyDown: keyDown)
                 .orThrow(ErrorMessage("key \(key) event empty"))
             if let flags { ev.flags = flags }
-            ev.postToPid(self.pid)
+            ev.postToPid(pid)
             if isSequoiaOrUp, !keyDown { // workaround courtesy https://github.com/pmanot
                 ev.flags = []
-                ev.postToPid(self.pid)
+                ev.postToPid(pid)
             }
         }
     }
 
-    private func press(key: CGKeyCode, flags: CGEventFlags? = nil, onMainThread: Bool = true) throws {
+    private func press(key: CGKeyCode, flags: CGEventFlags? = nil, onMainThread: Bool) throws {
         try perform(onMainThread: onMainThread) {
-            try post(key: key, flags: flags)
+            try postKeyEvents(key, flags)
         }
     }
 
-    private func pressMappedKey(_ key: Character, flags: CGEventFlags? = nil, onMainThread: Bool = true) throws {
-        try perform(onMainThread: onMainThread) {
-            guard let keyCode = KeyMap.shared[key] else { return }
-            try post(key: CGKeyCode(keyCode), flags: flags)
-        }
+    private func pressMappedKey(_ key: Character, flags: CGEventFlags? = nil, onMainThread: Bool) throws {
+        guard let keyCode = perform(onMainThread: true, { keyCodeForCharacter(key) }) else { return }
+        try press(key: CGKeyCode(keyCode), flags: flags, onMainThread: onMainThread)
     }
 
-    func `return`(onMainThread: Bool = true) throws {
+    func `return`(onMainThread: Bool = false) throws {
         try press(key: CGKeyCode(kVK_Return), onMainThread: onMainThread)
     }
 
-    func downArrow(onMainThread: Bool = true) throws {
+    func downArrow(onMainThread: Bool = false) throws {
         try press(key: CGKeyCode(kVK_DownArrow), onMainThread: onMainThread)
     }
 
-    func rightArrow(onMainThread: Bool = true) throws {
+    func rightArrow(onMainThread: Bool = false) throws {
         try press(key: CGKeyCode(kVK_RightArrow), onMainThread: onMainThread)
     }
 
-    func commandV(onMainThread: Bool = true) throws {
+    func commandV(onMainThread: Bool = false) throws {
         // sending CGKeyCode(kVK_ANSI_V) won't work on non-qwerty layouts where V key is in a different place
         try pressMappedKey("v", flags: .maskCommand, onMainThread: onMainThread)
     }
 
     /// marks as read/unread on ventura
-    func commandShiftU(onMainThread: Bool = true) throws {
+    func commandShiftU(onMainThread: Bool = false) throws {
         try pressMappedKey("u", flags: [.maskCommand, .maskShift], onMainThread: onMainThread)
     }
 
     /// selects next thread, both keys aren't the same in practice
-    func commandRightBracket(onMainThread: Bool = true) throws {
+    func commandRightBracket(onMainThread: Bool = false) throws {
         try pressMappedKey("]", flags: .maskCommand, onMainThread: onMainThread)
     }
 
     #if false
     /// selects first thread
-    func command1(onMainThread: Bool = true) throws {
+    func command1(onMainThread: Bool = false) throws {
         try pressMappedKey("1", flags: .maskCommand, onMainThread: onMainThread)
     }
     /// edits selected message
-    func commandE(onMainThread: Bool = true) throws {
+    func commandE(onMainThread: Bool = false) throws {
         try pressMappedKey("e", flags: .maskCommand, onMainThread: onMainThread)
     }
     /// selects prev thread, both keys aren't the same in practice
-    func commandLeftBracket(onMainThread: Bool = true) throws {
+    func commandLeftBracket(onMainThread: Bool = false) throws {
         try pressMappedKey("[", flags: .maskCommand, onMainThread: onMainThread)
     }
     /// selects first non-pinned thread
-    func commandOption1(onMainThread: Bool = true) throws {
+    func commandOption1(onMainThread: Bool = false) throws {
         try pressMappedKey("1", flags: [.maskCommand, .maskAlternate], onMainThread: onMainThread)
     }
-    func ctrlShiftTab(onMainThread: Bool = true) throws {
+    func ctrlShiftTab(onMainThread: Bool = false) throws {
         try press(key: CGKeyCode(kVK_Tab), flags: [.maskControl, .maskShift], onMainThread: onMainThread)
     }
-    func ctrlTab(onMainThread: Bool = true) throws {
+    func ctrlTab(onMainThread: Bool = false) throws {
         try press(key: CGKeyCode(kVK_Tab), flags: .maskControl, onMainThread: onMainThread)
     }
     #endif

src/IMessage/Sources/IMessage/MacPermissions.swift

@@ -80,6 +80,7 @@ public enum MacPermissions {
     }
 
     public static func askForAutomationAccess() async throws {
+        // Automation's TCC prompt is unreliable when OSA runs off the main actor.
         try await MainActor.run {
             try OSA.promptAutomationAccess()
         }