Keep a pending banner quiet once its pane is focused

Packages/macOS/CmuxNotifications/Sources/CmuxNotifications/NotificationDeliveryCoordinator.swift

@@ -75,9 +75,13 @@ public final class NotificationDeliveryCoordinator {
     }
 
     /// Presentation options for a notification delivered while the app is in
-    /// the foreground.
-    public func presentationOptions(for notification: UNNotification) -> UNNotificationPresentationOptions {
-        presentationOptions(notificationHasSound: notification.request.content.sound != nil)
+    /// the foreground. `keepsSoundQuiet` drops the sound for a banner whose
+    /// target pane became focused after the banner was scheduled.
+    public func presentationOptions(
+        for content: UNNotificationContent,
+        keepsSoundQuiet: Bool = false
+    ) -> UNNotificationPresentationOptions {
+        presentationOptions(notificationHasSound: content.sound != nil && !keepsSoundQuiet)
     }
 
     /// Handles a notification response from `UNUserNotificationCenterDelegate`.

Packages/macOS/CmuxNotifications/Tests/CmuxNotificationsTests/NotificationDeliveryCoordinatorTests.swift

@@ -295,6 +295,20 @@ struct NotificationDeliveryCoordinatorTests {
         #expect(audible.contains(.sound))
     }
 
+    @Test("presentation options drop sound for a banner whose pane became focused")
+    func presentationOptionsKeepSoundQuiet() {
+        let coordinator = makeCoordinator()
+        let content = UNMutableNotificationContent()
+        content.sound = .default
+
+        let quiet = coordinator.presentationOptions(for: content, keepsSoundQuiet: true)
+        #expect(quiet.contains(.banner))
+        #expect(quiet.contains(.list))
+        #expect(!quiet.contains(.sound))
+
+        #expect(coordinator.presentationOptions(for: content).contains(.sound))
+    }
+
     @Test("Feed permission always falls back to once when always is unsupported")
     func feedPermissionAlwaysFallsBackToOnce() {
         let feed = FakeFeedReplying()

Sources/AppDelegate.swift

@@ -18358,11 +18358,28 @@ final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCent
         withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
     ) {
         Task { @MainActor [weak self] in
-            let options = self?.notificationDelivery.presentationOptions(for: notification) ?? []
-            completionHandler(options)
+            completionHandler(self?.foregroundPresentationOptions(for: notification.request.content) ?? [])
         }
     }
 
+    /// Foreground presentation for a delivered banner. A banner whose pane became
+    /// focused after it was scheduled presents without sound.
+    func foregroundPresentationOptions(for content: UNNotificationContent) -> UNNotificationPresentationOptions {
+        let keepsSoundQuiet = notificationStore?.keepsPresentedNotificationQuiet(
+            userInfo: content.userInfo
+        ) ?? false
+        let options = notificationDelivery.presentationOptions(
+            for: content,
+            keepsSoundQuiet: keepsSoundQuiet
+        )
+#if DEBUG
+        cmuxDebugLog(
+            "notification.present hasSound=\(content.sound != nil ? 1 : 0) keepsSoundQuiet=\(keepsSoundQuiet ? 1 : 0) sound=\(options.contains(.sound) ? 1 : 0)"
+        )
+#endif
+        return options
+    }
+
     /// Installs window focus routing and returns the registrations to its lifecycle owner.
     @discardableResult
     func installMainWindowKeyObserver() -> [NSObjectProtocol] {

Sources/TerminalNotificationStore.swift

@@ -1651,6 +1651,18 @@ final class TerminalNotificationStore: ObservableObject {
         )
     }
 
+    /// A banner scheduled while its pane was in the background can reach
+    /// `willPresent` after the user focused that pane. It then presents without
+    /// sound, like a notification that arrives while the pane is focused.
+    func keepsPresentedNotificationQuiet(userInfo: [AnyHashable: Any]) -> Bool {
+        guard !NotificationSoundSettings.soundWhenFocused(),
+              let tabId = (userInfo["tabId"] as? String).flatMap(UUID.init(uuidString:)) else {
+            return false
+        }
+        let surfaceId = (userInfo["surfaceId"] as? String).flatMap(UUID.init(uuidString:))
+        return notificationFocusState(tabId: tabId, surfaceId: surfaceId).isFocusedSurfaceArrival
+    }
+
     private func deliverNotificationSideEffects(
         _ notification: TerminalNotification,
         isFocusedSurfaceArrival: Bool,

cmuxTests/NotificationAndMenuBarTests.swift

@@ -1698,6 +1698,66 @@ final class NotificationDockBadgeTests: XCTestCase {
         XCTAssertEqual(try focusedTerminalNotificationSoundEffect(soundWhenFocused: true), true)
     }
 
+    /// A banner scheduled for a background pane can reach `willPresent` after
+    /// the user focused that pane; it must present without sound by default.
+    func testPendingBannerForNowFocusedPanePresentsQuietlyByDefault() throws {
+        XCTAssertEqual(try pendingBannerPresentsSound(soundWhenFocused: nil), [false, true])
+    }
+
+    func testPendingBannerForNowFocusedPaneKeepsSoundWhenOptedIn() throws {
+        XCTAssertEqual(try pendingBannerPresentsSound(soundWhenFocused: true), [true, true])
+    }
+
+    /// Returns whether `willPresent` includes `.sound` for a banner that targets
+    /// the focused pane, then for the same banner once the app loses focus.
+    private func pendingBannerPresentsSound(soundWhenFocused: Bool?) throws -> [Bool] {
+        let appDelegate = try XCTUnwrap(AppDelegate.shared, "AppDelegate.shared must be set for this test")
+        let manager = TabManager()
+        let store = TerminalNotificationStore.shared
+        let defaults = UserDefaults.standard
+        let soundWhenFocusedKey = "notificationSoundWhenFocused"
+
+        let originalTabManager = appDelegate.tabManager
+        let originalNotificationStore = appDelegate.notificationStore
+        let originalAppFocusOverride = AppFocusState.overrideIsFocused
+        let originalSoundWhenFocused = defaults.object(forKey: soundWhenFocusedKey)
+        appDelegate.tabManager = manager
+        appDelegate.notificationStore = store
+        if let soundWhenFocused {
+            defaults.set(soundWhenFocused, forKey: soundWhenFocusedKey)
+        } else {
+            defaults.removeObject(forKey: soundWhenFocusedKey)
+        }
+        defer {
+            appDelegate.tabManager = originalTabManager
+            appDelegate.notificationStore = originalNotificationStore
+            AppFocusState.overrideIsFocused = originalAppFocusOverride
+            if let originalSoundWhenFocused {
+                defaults.set(originalSoundWhenFocused, forKey: soundWhenFocusedKey)
+            } else {
+                defaults.removeObject(forKey: soundWhenFocusedKey)
+            }
+        }
+
+        let workspace = try XCTUnwrap(manager.selectedWorkspace)
+        let terminalPanel = try XCTUnwrap(workspace.focusedTerminalPanel)
+        let content = UNMutableNotificationContent()
+        content.sound = .default
+        content.userInfo = [
+            "tabId": workspace.id.uuidString,
+            "surfaceId": terminalPanel.id.uuidString,
+        ]
+        var presentsSound: [Bool] = []
+        for appFocused in [true, false] {
+            AppFocusState.overrideIsFocused = appFocused
+            let options = appDelegate.foregroundPresentationOptions(for: content)
+            XCTAssertTrue(options.contains(.banner))
+            XCTAssertTrue(options.contains(.list))
+            presentsSound.append(options.contains(.sound))
+        }
+        return presentsSound
+    }
+
     /// Posts one notification to the focused terminal pane and returns the
     /// `sound` effect its suppressed local feedback receives.
     private func focusedTerminalNotificationSoundEffect(soundWhenFocused: Bool?) throws -> Bool? {