ci: consolidate platform pipelines and test prerequisites on macOS support

MeetingAssistant/Native/MacOsDesktopControls/main.swift

@@ -2,6 +2,7 @@ import AppKit
 import Carbon
 import Foundation
 import WebKit
+import UserNotifications
 
 struct Manifest: Decodable {
     let baseUrl: String
@@ -21,20 +22,36 @@ struct Hotkey: Decodable {
     let endpoint: String
 }
 
+enum RecordingState: Int, Decodable {
+    case idle = 0
+    case recording = 1
+    case summarizing = 2
+}
+
 struct RecordingStatus: Decodable {
     let isRecording: Bool
-    let state: String
+    let state: RecordingState
     let launchProfile: String?
 }
 
 @main
-final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
+@MainActor
+final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate, UNUserNotificationCenterDelegate {
     private let manifest: Manifest
-    private var status = RecordingStatus(isRecording: false, state: "Idle", launchProfile: nil)
+    private var status = RecordingStatus(isRecording: false, state: .idle, launchProfile: nil)
     private var statusItem: NSStatusItem!
     private var registeredHotkeys: [UInt32: Hotkey] = [:]
     private var timer: Timer?
     private var agentWindow: NSWindow?
+    private var independentAgentWindows: [String: NSWindow] = [:]
+    private var agentWindowState = DesktopAgentWindowState()
+    private var requests = DesktopUserRequestState()
+    private var fetchingRequests = false
+    private var fetchingWindows = false
+    private var authorizationInFlight = false
+    private var authorizationChecked = false
+    private var notificationsAuthorized = false
+    private lazy var notificationCenter = UNUserNotificationCenter.current()
 
     override init() {
         guard CommandLine.arguments.count == 2,
@@ -48,6 +65,19 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
     }
 
     static func main() {
+        if CommandLine.arguments.count == 2 && CommandLine.arguments[1] == "--self-test" {
+            runDesktopControlSelfTests()
+            return
+        }
+        // Notification activation after shutdown has no trusted service manifest.
+        if CommandLine.arguments.count == 1 {
+            fputs("Ignoring desktop notification activation without an active service manifest.\n", stderr)
+            return
+        }
+        guard Bundle.main.bundleIdentifier == "cloud.schweigert.meeting-assistant.desktop-controls" else {
+            fputs("Desktop controls must run from the signed MeetingAssistantDesktopControls.app bundle.\n", stderr)
+            exit(2)
+        }
         let application = NSApplication.shared
         let delegate = DesktopControls()
         application.delegate = delegate
@@ -55,6 +85,12 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
         application.run()
     }
 
+    func applicationWillFinishLaunching(_ notification: Notification) {
+        notificationCenter.delegate = self
+        notificationCenter.removeAllPendingNotificationRequests()
+        notificationCenter.removeAllDeliveredNotifications()
+    }
+
     func applicationDidFinishLaunching(_ notification: Notification) {
         statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
         statusItem.button?.image = NSImage(
@@ -64,19 +100,22 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
         menu.delegate = self
         statusItem.menu = menu
         registerHotkeys()
-        refreshStatus()
+        refresh()
         timer = Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { [weak self] _ in
-            self?.refreshStatus()
+            DispatchQueue.main.async { self?.refresh() }
         }
     }
 
     func applicationWillTerminate(_ notification: Notification) {
         timer?.invalidate()
+        notificationCenter.removeAllPendingNotificationRequests()
+        notificationCenter.removeAllDeliveredNotifications()
     }
 
     func menuWillOpen(_ menu: NSMenu) {
+        removeNotifications(requests.reconcile(requests.pending, now: Date()))
         rebuildMenu(menu)
-        refreshStatus()
+        refresh()
     }
 
     private func rebuildMenu(_ menu: NSMenu) {
@@ -102,17 +141,45 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
             }
         }
         menu.addItem(.separator())
+        let pending = NSMenuItem(title: "Pending requests (\(requests.pending.count))", action: nil, keyEquivalent: "")
+        let pendingMenu = NSMenu()
+        if requests.pending.isEmpty {
+            let empty = NSMenuItem(title: "No pending requests", action: nil, keyEquivalent: "")
+            empty.isEnabled = false
+            pendingMenu.addItem(empty)
+        }
+        for request in requests.pending {
+            let entry = NSMenuItem(title: request.title, action: nil, keyEquivalent: "")
+            entry.toolTip = request.message
+            let decisions = NSMenu()
+            let message = NSMenuItem(title: request.message, action: nil, keyEquivalent: "")
+            message.isEnabled = false
+            decisions.addItem(message)
+            decisions.addItem(.separator())
+            for action in request.actions {
+                let decision = item(action.label, #selector(answerRequest(_:)))
+                decision.representedObject = DesktopRequestDecision(request.id, action.id)
+                decision.isEnabled = !requests.isResponding(request.id)
+                decisions.addItem(decision)
+            }
+            entry.submenu = decisions
+            pendingMenu.addItem(entry)
+        }
+        pending.submenu = pendingMenu
+        menu.addItem(pending)
+        menu.addItem(.separator())
         menu.addItem(item("Exit", #selector(exitApplication)))
     }
 
     private var tooltip: String {
+        let suffix = requests.pending.isEmpty ? "" : " — \(requests.pending.count) pending request(s)"
         if status.isRecording {
-            return status.launchProfile.map { "Meeting Assistant — recording (\($0))" }
-                ?? "Meeting Assistant — recording"
+            return (status.launchProfile.map { "Meeting Assistant — recording (\($0))" }
+                ?? "Meeting Assistant — recording") + suffix
         }
-        return status.state.lowercased() == "summarizing"
+        return (status.state == .summarizing
             ? "Meeting Assistant — summarizing"
-            : "Meeting Assistant — idle"
+            : "Meeting Assistant — idle") + suffix
     }
 
     private func item(_ title: String, _ action: Selector) -> NSMenuItem {
@@ -122,24 +189,64 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
     }
 
     @objc private func openAgent() {
-        if agentWindow == nil {
-            let webView = WKWebView(frame: .zero)
-            let window = NSWindow(
-                contentRect: NSRect(x: 0, y: 0, width: 840, height: 760),
-                styleMask: [.titled, .closable, .miniaturizable, .resizable],
-                backing: .buffered,
-                defer: false)
-            window.title = "Meeting Summary Agent"
-            window.contentView = webView
-            window.center()
-            window.isReleasedWhenClosed = false
-            webView.load(URLRequest(url: URL(string: manifest.openAgentUrl)!))
-            agentWindow = window
+        if agentWindow == nil, let url = URL(string: manifest.openAgentUrl) {
+            agentWindow = makeAgentWindow(url)
         }
         NSApplication.shared.activate(ignoringOtherApps: true)
         agentWindow?.makeKeyAndOrderFront(nil)
     }
 
+    private func makeAgentWindow(_ url: URL) -> NSWindow {
+        let webView = WKWebView(frame: .zero)
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 840, height: 760),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered,
+            defer: false)
+        window.title = "Meeting Summary Agent"
+        window.contentView = webView
+        window.center()
+        window.isReleasedWhenClosed = false
+        webView.load(URLRequest(url: url))
+        return window
+    }
+
+    @objc private func answerRequest(_ sender: NSMenuItem) {
+        guard let decision = sender.representedObject as? DesktopRequestDecision else { return }
+        submitResponse(requestId: decision.requestId, action: decision.action)
+    }
+
+    private func submitResponse(requestId: String, action: String) {
+        guard let response = requests.beginResponse(baseUrl: manifest.baseUrl, requestId: requestId, action: action, now: Date()) else { return }
+        URLSession.shared.dataTask(with: response) { [weak self] _, response, error in
+            let accepted = error == nil && (response as? HTTPURLResponse).map { (200..<300).contains($0.statusCode) } == true
+            DispatchQueue.main.async {
+                guard let self else { return }
+                self.requests.completeResponse(requestId, accepted: accepted)
+                if accepted { self.removeNotifications([requestId]) }
+                if let error { desktopLog("User response failed: \(error.localizedDescription)") }
+                self.refresh()
+            }
+        }.resume()
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        completionHandler([.banner, .list, .sound])
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
+        // Closing the announcement is independent of deciding its menu request.
+        guard response.actionIdentifier != UNNotificationDismissActionIdentifier,
+              response.actionIdentifier != UNNotificationDefaultActionIdentifier,
+              let id = response.notification.request.content.userInfo["requestId"] as? String else {
+            completionHandler()
+            return
+        }
+        let action = response.actionIdentifier
+        DispatchQueue.main.async { [weak self] in self?.submitResponse(requestId: id, action: action) }
+        completionHandler()
+    }
+
     @objc private func startProfile(_ sender: NSMenuItem) {
         let profile = manifest.profiles[sender.tag]
         post(path: "/profiles/\(escaped(profile.name))/recording/start")
@@ -160,6 +267,114 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
         }
     }
 
+    private func refresh() {
+        removeNotifications(requests.reconcile(requests.pending, now: Date()))
+        updateStatusItem()
+        refreshStatus()
+        refreshRequests()
+        refreshAgentWindows()
+    }
+
+    private func updateStatusItem() {
+        statusItem.button?.image = NSImage(
+            systemSymbolName: status.isRecording ? "record.circle.fill" : "waveform.circle",
+            accessibilityDescription: tooltip)
+        statusItem.button?.toolTip = tooltip
+    }
+
+    private func refreshRequests() {
+        guard !fetchingRequests, let url = URL(string: manifest.baseUrl + "/desktop/requests") else { return }
+        fetchingRequests = true
+        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
+            var snapshot: [DesktopUserRequest]?
+            if let data, error == nil, (response as? HTTPURLResponse)?.statusCode == 200 {
+                do { snapshot = try decodeDesktopRequests(data) }
+                catch { desktopLog("Cannot decode pending desktop requests: \(error)") }
+            }
+            DispatchQueue.main.async {
+                guard let self else { return }
+                self.fetchingRequests = false
+                guard let snapshot else { return }
+                self.removeNotifications(self.requests.reconcile(snapshot, now: Date()))
+                self.updateStatusItem()
+                self.announcePendingRequests()
+            }
+        }.resume()
+    }
+
+    private func removeNotifications(_ ids: [String]) {
+        guard !ids.isEmpty else { return }
+        let identifiers = ids.map { "desktop-request." + $0 }
+        notificationCenter.removePendingNotificationRequests(withIdentifiers: identifiers)
+        notificationCenter.removeDeliveredNotifications(withIdentifiers: identifiers)
+    }
+
+    private func announcePendingRequests() {
+        guard !requests.notificationsToAnnounce().isEmpty else { return }
+        if !authorizationChecked {
+            guard !authorizationInFlight else { return }
+            authorizationInFlight = true
+            notificationCenter.getNotificationSettings { [weak self] settings in
+                DispatchQueue.main.async {
+                    guard let self else { return }
+                    if settings.authorizationStatus == .notDetermined {
+                        self.notificationCenter.requestAuthorization(options: [.alert, .sound]) { [weak self] granted, error in
+                            DispatchQueue.main.async {
+                                if let error { desktopLog("Notification authorization failed: \(error.localizedDescription)") }
+                                self?.finishNotificationAuthorization(granted)
+                            }
+                        }
+                    } else {
+                        self.finishNotificationAuthorization(settings.authorizationStatus == .authorized || settings.authorizationStatus == .provisional)
+                    }
+                }
+            }
+            return
+        }
+        guard notificationsAuthorized else { return }
+        notificationCenter.setNotificationCategories(Set(requests.pending.map { $0.notificationCategory() }))
+        for request in requests.notificationsToAnnounce() {
+            requests.markAnnounced(request.id)
+            notificationCenter.add(request.notificationRequest()) { error in
+                if let error { desktopLog("Cannot schedule desktop notification \(request.id): \(error.localizedDescription)") }
+                else { desktopLog("Scheduled desktop notification \(request.id)") }
+            }
+        }
+    }
+
+    private func finishNotificationAuthorization(_ granted: Bool) {
+        authorizationChecked = true
+        authorizationInFlight = false
+        notificationsAuthorized = granted
+        desktopLog(granted ? "Desktop notifications authorized." : "Desktop notifications unavailable; pending requests remain in the menu.")
+        removeNotifications(requests.reconcile(requests.pending, now: Date()))
+        announcePendingRequests()
+    }
+
+    private func refreshAgentWindows() {
+        guard !fetchingWindows, let url = URL(string: manifest.baseUrl + "/desktop/agent-windows") else { return }
+        fetchingWindows = true
+        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
+            let windows = data.flatMap { data in
+                error == nil && (response as? HTTPURLResponse)?.statusCode == 200
+                    ? try? JSONDecoder().decode([DesktopAgentWindow].self, from: data) : nil
+            }
+            DispatchQueue.main.async {
+                guard let self else { return }
+                self.fetchingWindows = false
+                guard let windows else { return }
+                for requested in self.agentWindowState.takeUnopened(windows) {
+                    guard let url = URL(string: requested.url) else { continue }
+                    let window = self.makeAgentWindow(url)
+                    self.independentAgentWindows[requested.id] = window
+                    NSApplication.shared.activate(ignoringOtherApps: true)
+                    window.makeKeyAndOrderFront(nil)
+                    desktopLog("Opened independent workflow agent window \(requested.id)")
+                }
+            }
+        }.resume()
+    }
+
     private func refreshStatus() {
         guard let url = URL(string: manifest.statusUrl) else { return }
         URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
@@ -167,9 +382,7 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
                   let next = try? JSONDecoder().decode(RecordingStatus.self, from: data) else { return }
             DispatchQueue.main.async {
                 self?.status = next
-                self?.statusItem.button?.image = NSImage(
-                    systemSymbolName: next.isRecording ? "record.circle.fill" : "waveform.circle",
-                    accessibilityDescription: self?.tooltip)
+                self?.updateStatusItem()
             }
         }.resume()
     }
@@ -184,7 +397,7 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
         request.httpMethod = "POST"
         URLSession.shared.dataTask(with: request) { [weak self] _, _, _ in
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-                self?.refreshStatus()
+                self?.refresh()
             }
         }.resume()
     }
@@ -239,6 +452,20 @@ final class DesktopControls: NSObject, NSApplicationDelegate, NSMenuDelegate {
     }
 }
 
+private final class DesktopRequestDecision: NSObject {
+    let requestId: String
+    let action: String
+
+    init(_ requestId: String, _ action: String) {
+        self.requestId = requestId
+        self.action = action
+    }
+}
+
+private func desktopLog(_ message: String) {
+    fputs("\(message)\n", stderr)
+}
+
 private func tokens(_ shortcut: String) -> [String] {
     shortcut.uppercased().split(separator: "+").map(String.init)
 }