CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
fix: 将任务等待通知扩展到阻塞式提问
Bobe44bed62e033
diff --git a/CodexBar/Models/ActivityModels.swift b/CodexBar/Models/ActivityModels.swiftindex 73d8dd0..11f45f4 100644--- a/CodexBar/Models/ActivityModels.swift+++ b/CodexBar/Models/ActivityModels.swift@@ -102,18 +102,16 @@ nonisolated struct ActivitySnapshot: Equatable {runningTasks.filter { $0.presentation?.waiting == nil }}- /// 防睡眠将明确阻塞的提问归入等待, 不改变任务的审批和保护状态+ /// 通知和防睡眠共用阻塞等待, 不改变面板展示或任务的审批和保护状态+ var blockingWaitingTaskIDs: Set<UUID> {+ Set(waitingTasks.map(\.id)).union(+ runningTasks.lazy.filter { $0.presentation?.hasBlockingInputRequest == true }.map(\.id)+ )+ }+var keepAliveTaskIDs: (running: Set<UUID>, waiting: Set<UUID>) {- var running = Set<UUID>()- var waiting = Set(waitingTasks.map(\.id))- for task in runningTasks {- if task.presentation?.hasBlockingInputRequest == true {- waiting.insert(task.id)- } else {- running.insert(task.id)- }- }- return (running, waiting)+ let waiting = blockingWaitingTaskIDs+ return (Set(runningTasks.map(\.id)).subtracting(waiting), waiting)}var panelPrimaryActivity: CodexPrimaryActivity {@@ -217,9 +215,9 @@ nonisolated enum CodexPrimaryActivity: Equatable {case idle}-/// 只有 live 事件 或 turn 生命周期会发布 transition, bootstrap 永远不会触发历史通知+/// 等待携带实际起点, monitor 在初始化和恢复期间屏蔽通知nonisolated enum ActivityTransition: Equatable {- case waitingApproval(ActivityTaskSnapshot)+ case waiting(ActivityTaskSnapshot, since: Date)case completed(ActivityCompletion)}diff --git a/CodexBar/Services/Activity/ActivityLivePresentation.swift b/CodexBar/Services/Activity/ActivityLivePresentation.swiftindex 1d49aca..0d6676e 100644--- a/CodexBar/Services/Activity/ActivityLivePresentation.swift+++ b/CodexBar/Services/Activity/ActivityLivePresentation.swift@@ -29,9 +29,13 @@ nonisolated struct ActivityLiveSummary: Equatable {var toolCount: Int?var planCompleted: Int?var planTotal: Int?- var hasBlockingInputRequest = false+ var blockingInputSince: Date?var isReviewing = falsevar updatedAt: Date = .distantPast++ var hasBlockingInputRequest: Bool {+ blockingInputSince != nil+ }}/// 与历史统计和审批策略独立的内存状态, 连接失效时整体丢弃@@ -79,7 +83,7 @@ nonisolated struct ActivityLivePresentation {current: waiting?.label ?? current.label, waiting: waiting, recent: recent,toolCount: inventoryKnown ? items.values.filter(\.isTool).count : nil,planCompleted: planCompleted, planTotal: planTotal,- hasBlockingInputRequest: requests.values.contains { $0.isBlocking == true },+ blockingInputSince: requests.values.filter { $0.isBlocking == true }.compactMap(\.since).min(),isReviewing: isReviewing, updatedAt: current.at)}diff --git a/CodexBar/Services/Activity/ActivityMonitor.swift b/CodexBar/Services/Activity/ActivityMonitor.swiftindex 5636690..8e2b0f2 100644--- a/CodexBar/Services/Activity/ActivityMonitor.swift+++ b/CodexBar/Services/Activity/ActivityMonitor.swift@@ -436,9 +436,9 @@ final class ActivityMonitor: ObservableObject {let date: Dateswitch transition {case let .completed(completion): date = completion.completedAt- case let .waitingApproval(snapshot):- guard tasks.values.contains(where: { $0.displayID == snapshot.id && $0.state == .waitingApproval }) else { return false }- date = snapshot.stateChangedAt+ case let .waiting(task, since):+ guard snapshot.blockingWaitingTaskIDs.contains(task.id) else { return false }+ date = since}return date >= turnTransitionNotBefore && now.timeIntervalSince(date) <= 10}diff --git a/CodexBar/Services/Activity/ActivityTask.swift b/CodexBar/Services/Activity/ActivityTask.swiftindex 2956966..3618661 100644--- a/CodexBar/Services/Activity/ActivityTask.swift+++ b/CodexBar/Services/Activity/ActivityTask.swift@@ -139,10 +139,15 @@ nonisolated struct ActivityTask {var result = (waiting ?? root ?? live.max { $0.1.updatedAt < $1.1.updatedAt })!.1result.recent = live.compactMap(\.1.recent).max { $0.at < $1.at }result.toolCount = live.allSatisfy { $0.1.toolCount != nil } ? live.reduce(0) { $0 + ($1.1.toolCount ?? 0) } : nil- result.hasBlockingInputRequest = live.contains { $0.1.hasBlockingInputRequest }+ result.blockingInputSince = live.compactMap(\.1.blockingInputSince).min()return result}+ var blockingWaitStartedAt: Date? {+ [state == .waitingApproval ? stateChangedAt : nil, livePresentation?.blockingInputSince]+ .compactMap(\.self).min()+ }+var turnReference: ActivityTurnReference {ActivityTurnReference(threadID: key.threadID,diff --git a/CodexBar/Services/Activity/ActivityTaskGraph.swift b/CodexBar/Services/Activity/ActivityTaskGraph.swiftindex c4f1ba4..7ca84b5 100644--- a/CodexBar/Services/Activity/ActivityTaskGraph.swift+++ b/CodexBar/Services/Activity/ActivityTaskGraph.swift@@ -17,22 +17,32 @@ nonisolated struct ActivityTaskGraph {mutating func update(events: [ActivityDataRecord], source: ActivityEventSource, lifecycle: TurnLifecycleSnapshot) -> [ActivityTransition] {- let previouslyWaiting = Set(tasks.values.filter { $0.state == .waitingApproval }.map(\.displayID))+ let previouslyWaiting = Set(tasks.values.filter { $0.blockingWaitStartedAt != nil }.map(\.displayID))+ let previouslyAwaitingApproval = Set(tasks.values.filter { $0.state == .waitingApproval }.map(\.displayID))var transitions = consume(events, source: source)transitions += reconcile(lifecycle.lifecycleStates(for: lifecycleReferences()))- for (key, task) in tasks where task.state == .waitingApproval && !previouslyWaiting.contains(task.displayID) {+ for (key, task) in tasks where task.state == .waitingApproval && !previouslyAwaitingApproval.contains(task.displayID) {if let approval = task.displayedApproval {tasks[key]?.stateChangedAt = approval.requestedAt}}- let waiting = Dictionary(uniqueKeysWithValues: tasks.values.filter { $0.state == .waitingApproval }.map { ($0.displayID, $0.snapshot) })+ var waiting: [UUID: (snapshot: ActivityTaskSnapshot, since: Date)] = [:]+ for task in tasks.values {+ guard let since = task.blockingWaitStartedAt else { continue }+ let snapshot = task.snapshot+ waiting[task.displayID] = (snapshot, since)+ // 提问只存在于实时内存状态, 不产生历史事件, 在生命周期核对后发布+ if snapshot.presentation?.hasBlockingInputRequest == true {+ transitions.append(.waiting(snapshot, since: since))+ }+ }var notified = Set<UUID>()// 事件中的等待只是候选, 提醒必须使用本次核对后的最终状态return transitions.compactMap { transition in- guard case let .waitingApproval(snapshot) = transition else { return transition }+ guard case let .waiting(snapshot, _) = transition else { return transition }guard !previouslyWaiting.contains(snapshot.id), let current = waiting[snapshot.id],notified.insert(snapshot.id).inserted else { return nil }- return .waitingApproval(current)+ return .waiting(current.snapshot, since: current.since)}}@@ -338,7 +348,7 @@ nonisolated struct ActivityTaskGraph {var seen = Set<ActivityTaskKey>()return keys.reversed().compactMap { key inguard seen.insert(key).inserted, let task = tasks[key], task.state == .waitingApproval else { return nil }- return .waitingApproval(task.snapshot)+ return .waiting(task.snapshot, since: task.blockingWaitStartedAt ?? task.stateChangedAt)}.reversed()}}diff --git a/CodexBar/Services/Notifications/NotificationService.swift b/CodexBar/Services/Notifications/NotificationService.swiftindex e22bc98..431da10 100644--- a/CodexBar/Services/Notifications/NotificationService.swift+++ b/CodexBar/Services/Notifications/NotificationService.swift@@ -13,15 +13,38 @@ nonisolated enum AutoResetFailureNotice: String, Sendable {/// 订阅额度与实时活动, 统一处理提醒条件, 去重, 触觉反馈与本地通知发送@MainActorfinal class NotificationService: NSObject {+ struct Delivery {+ var setDelegate: (any UNUserNotificationCenterDelegate) -> Void = {+ UNUserNotificationCenter.current().delegate = $0+ }++ var add: (UNNotificationRequest) async throws -> Void = {+ try await UNUserNotificationCenter.current().add($0)+ }++ var remove: ([String]) -> Void = {+ let center = UNUserNotificationCenter.current()+ center.removeDeliveredNotifications(withIdentifiers: $0)+ center.removePendingNotificationRequests(withIdentifiers: $0)+ }+ }+private let settings: NotificationSettingsprivate let statusViewModel: CodexStatusViewModelprivate let activityMonitor: ActivityMonitorprivate let defaults: UserDefaults+ private let delivery: Deliveryprivate nonisolated let openMenuSurface: @MainActor @Sendable () -> Voidprivate var cancellables = Set<AnyCancellable>()private var taskHapticFeedbackTask: Task<Void, Never>?private var taskWaitingNotificationIdentifiers = Set<String>()+ #if CODEXBAR_TESTING+ private(set) var lastSubmissionTaskForTesting: Task<Bool, Never>?+ var taskWaitingNotificationIdentifiersForTesting: Set<String> {+ taskWaitingNotificationIdentifiers+ }+ #endifprivate let creditExpiryReminderScheduler = ReminderCheckScheduler()private var latestQuotaSnapshot: CodexQuotaSnapshot?@@ -56,12 +79,14 @@ final class NotificationService: NSObject {statusViewModel: CodexStatusViewModel,activityMonitor: ActivityMonitor,defaults: UserDefaults = .standard,+ delivery: Delivery = Delivery(),openMenuSurface: @escaping @MainActor @Sendable () -> Void) {self.settings = settingsself.statusViewModel = statusViewModelself.activityMonitor = activityMonitorself.defaults = defaults+ self.delivery = deliveryself.openMenuSurface = openMenuSurfacelet storedDedupKeys = defaults.stringArray(forKey: Self.sentKeysKey) ?? []sentDedupKeys = storedDedupKeys.filter { !$0.hasPrefix(Self.legacyResetDedupKeyPrefix) }@@ -73,7 +98,7 @@ final class NotificationService: NSObject {}func start() {- UNUserNotificationCenter.current().delegate = self+ delivery.setDelegate(self)settings.refreshAuthorizationStatus()statusViewModel.$snapshot@@ -126,7 +151,7 @@ final class NotificationService: NSObject {}switch transition {- case let .waitingApproval(task):+ case let .waiting(task, _):guard settings.isTaskWaitingEnabled else {return}@@ -138,10 +163,7 @@ final class NotificationService: NSObject {sound: settings.taskWaitingSound,identifier: identifier,isStillRelevant: { [weak self] in- self?.isTaskStillWaiting(- taskID,- notificationIdentifier: identifier- ) ?? false+ self?.activityMonitor.snapshot.blockingWaitingTaskIDs.contains(taskID) ?? false},onSubmissionFailure: { [weak self] inself?.taskWaitingNotificationIdentifiers.remove(identifier)@@ -160,22 +182,9 @@ final class NotificationService: NSObject {}}- private func isTaskStillWaiting(- _ taskID: UUID,- notificationIdentifier: String- ) -> Bool {- let isStillWaiting = activityMonitor.snapshot.waitingTasks.contains {- $0.id == taskID- }- if !isStillWaiting {- taskWaitingNotificationIdentifiers.remove(notificationIdentifier)- }- return isStillWaiting- }-private func reconcileTaskWaitingNotifications(with snapshot: ActivitySnapshot) {- let activeIdentifiers = Set(snapshot.waitingTasks.map {- Self.taskWaitingNotificationIdentifier(for: $0.id)+ let activeIdentifiers = Set(snapshot.blockingWaitingTaskIDs.map {+ Self.taskWaitingNotificationIdentifier(for: $0)})let obsoleteIdentifiers = taskWaitingNotificationIdentifiers.subtracting(activeIdentifiers)guard !obsoleteIdentifiers.isEmpty else {@@ -622,7 +631,7 @@ final class NotificationService: NSObject {content: content,trigger: nil)- return Task { @MainActor [weak self] in+ let task = Task { @MainActor [weak self] inawait self?.deliver(request,kind: kind,@@ -632,6 +641,10 @@ final class NotificationService: NSObject {retryCount: retryCount) ?? false}+ #if CODEXBAR_TESTING+ lastSubmissionTaskForTesting = task+ #endif+ return task}/// 返回值是"这条通知真的提交出去了", 调用方据此决定要不要记下已通知@@ -659,7 +672,7 @@ final class NotificationService: NSObject {return false}do {- try await UNUserNotificationCenter.current().add(request)+ try await delivery.add(request)guard isStillRelevant?() != false else {// 投递后任务状态又变了, 撤回避免用户看到过期提醒let details = LogFields.joined(@@ -691,9 +704,7 @@ final class NotificationService: NSObject {}private func removeNotifications(withIdentifiers identifiers: [String]) {- let center = UNUserNotificationCenter.current()- center.removeDeliveredNotifications(withIdentifiers: identifiers)- center.removePendingNotificationRequests(withIdentifiers: identifiers)+ delivery.remove(identifiers)}private nonisolated static func accountKey(for snapshot: CodexQuotaSnapshot) -> String {diff --git a/CodexBar/Services/Settings/NotificationSettings.swift b/CodexBar/Services/Settings/NotificationSettings.swiftindex f732b4d..9ba8ff5 100644--- a/CodexBar/Services/Settings/NotificationSettings.swift+++ b/CodexBar/Services/Settings/NotificationSettings.swift@@ -65,12 +65,19 @@ final class NotificationSettings: ObservableObject {static let taskCompletionDurationOptions = [30, 60, 120, 300]private let defaults: UserDefaults+ private let readAuthorizationStatus: () async -> UNAuthorizationStatusprivate var authorizationTask: Task<Void, Never>?private var isRequestingAuthorization = falseprivate var appActivationObserver: AnyCancellable?- init(defaults: UserDefaults = .standard) {+ init(+ defaults: UserDefaults = .standard,+ readAuthorizationStatus: @escaping () async -> UNAuthorizationStatus = {+ await UNUserNotificationCenter.current().notificationSettings().authorizationStatus+ }+ ) {self.defaults = defaults+ self.readAuthorizationStatus = readAuthorizationStatusisEnabled = defaults.bool(forKey: Self.enabledKey)isLowQuotaEnabled = Self.bool(from: defaults, key: Self.lowQuotaEnabledKey, defaultValue: true)isQuotaResetEnabled = Self.bool(from: defaults, key: Self.quotaResetEnabledKey, defaultValue: true)@@ -230,9 +237,8 @@ final class NotificationSettings: ObservableObject {return}authorizationTask?.cancel()- authorizationTask = Task { @MainActor [weak self] in- let status = await UNUserNotificationCenter.current()- .notificationSettings().authorizationStatus+ authorizationTask = Task { @MainActor [weak self, readAuthorizationStatus] in+ let status = await readAuthorizationStatus()guard let self, !Task.isCancelled else {return}diff --git a/Tests/App/Activity/ActivityUpdateTests.swift b/Tests/App/Activity/ActivityUpdateTests.swiftindex d21f053..3eea810 100644--- a/Tests/App/Activity/ActivityUpdateTests.swift+++ b/Tests/App/Activity/ActivityUpdateTests.swift@@ -46,12 +46,13 @@ struct ActivityUpdateTests {#expect((task.state == .waitingApproval) == expectsWaiting)#expect(transitions.count == (expectsWaiting ? 1 : 0))if expectsWaiting {- guard case let .waitingApproval(published) = try #require(transitions.first) else {+ guard case let .waiting(published, since) = try #require(transitions.first) else {Issue.record("Expected waiting transition")return}#expect(published == task.snapshot)#expect(published.stateChangedAt == now.addingTimeInterval(scenario == "replaced" ? -1 : -2))+ #expect(since == published.stateChangedAt)}let repeated = graph.update(events: [], source: .bootstrap, lifecycle: snapshot)#expect(repeated.isEmpty)@@ -278,6 +279,138 @@ struct ActivityUpdateTests {try server.finish()}+ @Test(arguments: [true, false, nil] as [Bool?], [false, true])+ func inputWaitNotifiesOnlyWhenBlocking(isBlocking: Bool?, inChild: Bool) throws {+ let now = Date()+ var reducer = try approvalReducer(at: now)+ var graph = ActivityTaskGraph()+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ _ = try reducer.consume(inputRequest(id: "async", blocking: false), now: now.addingTimeInterval(-20))+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ let thread = inChild ? "child" : "thread-a"+ let turn = inChild ? "child-turn" : "turn-a"+ let since = now.addingTimeInterval(-1)+ let input = try inputRequest(id: "blocking", blocking: isBlocking, thread: thread, turn: turn)+ #expect(reducer.consume(input, now: since).isEmpty)+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ let task = try #require(graph.tasks.values.first)+ #expect(task.state == .running)+ #expect(task.snapshot.presentation?.waiting?.since == now.addingTimeInterval(-20))+ #expect(task.snapshot.presentation?.blockingInputSince == (isBlocking == true ? since : nil))+ #expect(transitions == (isBlocking == true ? [.waiting(task.snapshot, since: since)] : []))+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)++ let userMessage = try TestFixtures.decode(ActivityInput.self, """+ {"method":"item/completed","params":{"threadId":"\(thread)","turnId":"\(turn)",+ "item":{"id":"reply","type":"userMessage","content":[{"type":"text","text":"Continue"}]}}}+ """)+ _ = reducer.consume(userMessage, now: now)+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ #expect(graph.tasks.values.first?.snapshot.presentation?.hasBlockingInputRequest == (isBlocking == true))++ _ = try reducer.consume(resolvedRequest(id: "blocking", thread: thread), now: now)+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == nil)+ _ = reducer.consume(input, now: now)+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).count == (isBlocking == true ? 1 : 0))+ }++ @Test(arguments: [false, true])+ func resolvedOrEndedInputDoesNotNotify(ended: Bool) throws {+ let now = Date()+ var reducer = try approvalReducer(at: now)+ var graph = ActivityTaskGraph()+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ _ = try reducer.consume(inputRequest(id: "input", blocking: true), now: now)+ let resolution = try ended ? TestFixtures.decode(ActivityInput.self, """+ {"method":"turn/completed","params":{"threadId":"thread-a","turn":{"id":"turn-a","status":"completed","completedAt":\(now.timeIntervalSince1970)}}}+ """) : resolvedRequest(id: "input")+ _ = reducer.consume(resolution, now: now)+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ #expect(!transitions.contains {+ if case .waiting = $0 {+ true+ } else {+ false+ }+ })+ #expect(graph.tasks.values.allSatisfy { $0.blockingWaitStartedAt == nil })+ }++ @Test func approvalAndBlockingInputsShareOneWaitingPeriod() throws {+ let now = Date(timeIntervalSince1970: floor(Date().timeIntervalSince1970))+ var reducer = try approvalReducer(at: now)+ var graph = ActivityTaskGraph()+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ let approvals = try reducer.consume(approvalRequest(id: "approval", at: now), now: now)+ #expect(graph.update(events: approvals, source: .live, lifecycle: lifecycle(reducer, at: now)).count == 1)+ for (id, thread, turn, offset) in [("first", "thread-a", "turn-a", 1.0), ("second", "child", "child-turn", 2.0)] {+ _ = try reducer.consume(inputRequest(id: id, blocking: true, thread: thread, turn: turn), now: now.addingTimeInterval(offset))+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ }+ for (id, thread, remaining) in [("approval", "child", 1.0), ("first", "thread-a", 2.0)] {+ _ = try reducer.consume(resolvedRequest(id: id, thread: thread), now: now.addingTimeInterval(3))+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == now.addingTimeInterval(remaining))+ }+ _ = try reducer.consume(resolvedRequest(id: "second", thread: "child"), now: now.addingTimeInterval(4))+ #expect(graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now)).isEmpty)+ #expect(graph.tasks.values.first?.blockingWaitStartedAt == nil)+ }++ @Test(arguments: ["live", "bootstrap", "recovery", "unavailable", "stale", "before-cutoff"])+ func monitorFiltersBlockingWaitsAndClearsResolvedRequests(scenario: String) throws {+ let directory = try TestDirectory()+ defer { try? directory.remove() }+ let preferences = try TestPreferences()+ defer { preferences.remove() }+ let monitor = ActivityMonitor(+ protectionSettings: ProtectionSettings(defaults: preferences.defaults),+ protectionStore: ProtectionStore(directoryURL: directory.url), activityDataDirectoryURL: directory.url+ )+ let now = Date()+ monitor.isActivitySourceHealthy = scenario != "unavailable"+ monitor.isBootstrapping = scenario == "bootstrap"+ monitor.isProtectionRecoveryInProgress = scenario == "recovery"+ monitor.turnTransitionNotBefore = now.addingTimeInterval(scenario == "before-cutoff" ? 0 : -60)+ var reducer = try approvalReducer(at: now)+ var graph = ActivityTaskGraph()+ _ = graph.update(events: [TestFixtures.event(at: now.addingTimeInterval(-60))], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ _ = try reducer.consume(inputRequest(id: "async", blocking: false), now: now.addingTimeInterval(-30))+ _ = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ _ = try reducer.consume(inputRequest(id: "input", blocking: true), now: now.addingTimeInterval(scenario == "stale" ? -20 : -1))+ let transitions = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ let readerID = UUID()+ var published: [ActivityTransition] = []+ let observation = monitor.transitionPublisher.sink { published.append($0) }+ defer { observation.cancel() }+ monitor.consume(update(graph, readerID: readerID, revision: 1, transitions: transitions))+ #expect(published.count == (scenario == "live" ? 1 : 0))+ #expect(monitor.snapshot.waitingTasks.isEmpty)+ #expect(monitor.snapshot.blockingWaitingTaskIDs.count == 1)+ #expect(monitor.snapshot.keepAliveTaskIDs.waiting == monitor.snapshot.blockingWaitingTaskIDs)+ _ = try reducer.consume(resolvedRequest(id: "input"), now: now)+ let resolved = graph.update(events: [], source: .bootstrap, lifecycle: lifecycle(reducer, at: now))+ monitor.consume(update(graph, readerID: readerID, revision: 2, transitions: resolved))+ #expect(monitor.snapshot.blockingWaitingTaskIDs.isEmpty)+ #expect(monitor.snapshot.panelWaitingTasks.count == 1)+ #expect(try !monitor.isCurrentTransition(#require(transitions.first), now: now))+ #expect(published.count == (scenario == "live" ? 1 : 0))+ }++ private func inputRequest(id: String, blocking: Bool?, thread: String = "thread-a", turn: String = "turn-a") throws -> ActivityInput {+ let blocking = blocking.map { String($0) } ?? "null"+ return try TestFixtures.decode(ActivityInput.self, """+ {"id":"\(id)","method":"item/tool/requestUserInput","params":{"threadId":"\(thread)","turnId":"\(turn)","isBlocking":\(blocking)}}+ """)+ }++ private func resolvedRequest(id: String, thread: String = "thread-a") throws -> ActivityInput {+ try TestFixtures.decode(ActivityInput.self, """+ {"method":"serverRequest/resolved","params":{"threadId":"\(thread)","requestId":"\(id)"}}+ """)+ }+private func approvalReducer(at now: Date) throws -> AppServerActivityReducer {var reducer = AppServerActivityReducer()let root = try TestFixtures.decode(ActivityThread.self, #"{"id":"thread-a","source":"cli","status":{"type":"active"}}"#)diff --git a/Tests/App/Notifications/TaskWaitingNotificationTests.swift b/Tests/App/Notifications/TaskWaitingNotificationTests.swiftnew file mode 100644index 0000000..d803655--- /dev/null+++ b/Tests/App/Notifications/TaskWaitingNotificationTests.swift@@ -0,0 +1,222 @@+import Foundation+import Testing+import UserNotifications++struct TaskWaitingNotificationTests {+ @Test(arguments: [false, true])+ func resolvedBeforeSubmissionSkipsDeliveryAndClearsTracking(blockingInput: Bool) async throws {+ let fixture = try Fixture()+ defer { fixture.cleanUp() }+ try await fixture.start()+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting == [fixture.identifier])++ try fixture.resolveWaiting()+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ #expect(fixture.delivery.attempts.isEmpty)+ #expect(await submission.value == false)+ #expect(fixture.delivery.attempts.isEmpty)+ #expect(fixture.delivery.delivered.isEmpty)+ #expect(fixture.delivery.removals == [[fixture.identifier]])+ }++ @Test(arguments: [false, true])+ func resolvedDuringSubmissionWithdrawsLateDelivery(blockingInput: Bool) async throws {+ let fixture = try Fixture()+ defer { fixture.cleanUp() }+ try await fixture.start()+ fixture.delivery.suspendsSubmissions = true+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)+ try await waitUntil { fixture.delivery.hasPendingSubmission }++ try fixture.resolveWaiting()+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ #expect(fixture.delivery.removals == [[fixture.identifier]])+ fixture.delivery.resumeSubmission()+ #expect(await submission.value == false)+ #expect(fixture.delivery.attempts.count == 1)+ #expect(fixture.delivery.delivered.isEmpty)+ #expect(fixture.delivery.removals == [[fixture.identifier], [fixture.identifier]])+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ }++ @Test(arguments: [false, true])+ func resolvedAfterDeliveryUsesSnapshotToWithdrawAndClearTracking(blockingInput: Bool) async throws {+ let fixture = try Fixture()+ defer { fixture.cleanUp() }+ try await fixture.start()+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)+ #expect(await submission.value)+ #expect(fixture.delivery.delivered == [fixture.identifier])+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting == [fixture.identifier])++ try fixture.resolveWaiting(keepsNonblockingQuestion: true)+ #expect(fixture.monitor.snapshot.panelWaitingTasks.count == 1)+ #expect(fixture.monitor.snapshot.blockingWaitingTaskIDs.isEmpty)+ #expect(fixture.delivery.delivered.isEmpty)+ #expect(fixture.delivery.removals == [[fixture.identifier]])+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ }++ @Test(arguments: [false, true])+ func exhaustedSubmissionRetriesClearTrackingWhileTaskStillWaits(blockingInput: Bool) async throws {+ let fixture = try Fixture()+ defer { fixture.cleanUp() }+ try await fixture.start()+ fixture.delivery.failuresRemaining = 2+ let submission = try fixture.enterWaiting(blockingInput: blockingInput)+ #expect(await submission.value == false)+ #expect(fixture.delivery.attempts.count == 2)+ #expect(fixture.monitor.snapshot.blockingWaitingTaskIDs == [fixture.taskID])+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ #expect(fixture.delivery.delivered.isEmpty)+ #expect(fixture.delivery.removals.isEmpty)++ try fixture.resolveWaiting()+ #expect(fixture.delivery.removals.isEmpty)+ let retried = try fixture.enterWaiting(blockingInput: blockingInput)+ #expect(await retried.value)+ #expect(fixture.delivery.delivered == [fixture.identifier])+ try fixture.resolveWaiting()+ #expect(fixture.delivery.removals == [[fixture.identifier]])+ #expect(fixture.service.taskWaitingNotificationIdentifiersForTesting.isEmpty)+ }+}++private func waitUntil(_ condition: () -> Bool) async throws {+ let deadline = ContinuousClock.now.advanced(by: .seconds(2))+ while !condition(), ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(5))+ }+ try #require(condition(), "Notification operation did not reach the expected state")+}++private final class Fixture {+ let directory: TestDirectory+ let preferences: TestPreferences+ let settings: NotificationSettings+ let monitor: ActivityMonitor+ let service: NotificationService+ let delivery = TestNotificationDelivery()+ let taskID = UUID()+ private let key = ActivityTaskKey(thread: "thread-a", turn: "turn-a")+ private let owner = ActivityExecutionKey(agentThreadID: nil, turnID: "turn-a")+ private var graph = ActivityTaskGraph()++ var identifier: String {+ "taskWaiting|\(taskID.uuidString)"+ }++ init() throws {+ directory = try TestDirectory()+ preferences = try TestPreferences()+ preferences.defaults.set(true, forKey: "Notification.isEnabled")+ settings = NotificationSettings(defaults: preferences.defaults, readAuthorizationStatus: { .authorized })+ monitor = ActivityMonitor(+ protectionSettings: ProtectionSettings(defaults: preferences.defaults),+ protectionStore: ProtectionStore(directoryURL: directory.url), activityDataDirectoryURL: directory.url+ )+ let model = CodexStatusViewModel(+ service: CodexStatusService(socketURL: directory.url.appendingPathComponent("unused.sock"), logStorage: nil),+ defaults: preferences.defaults+ )+ service = NotificationService(+ settings: settings, statusViewModel: model, activityMonitor: monitor,+ defaults: preferences.defaults, delivery: delivery.client, openMenuSurface: {}+ )+ let now = Date()+ graph.tasks[key] = ActivityTask(+ displayID: taskID, key: key, event: TestFixtures.event(at: now),+ state: .running, startedAt: now, progressGeneration: 0+ )+ monitor.isActivitySourceHealthy = true+ monitor.turnTransitionNotBefore = now+ }++ func start() async throws {+ service.start()+ try await waitUntil { self.settings.canDeliver }+ }++ func enterWaiting(blockingInput: Bool) throws -> Task<Bool, Never> {+ let now = Date()+ if blockingInput {+ graph.tasks[key]?.executions[owner]?.presentation = try question(blocking: true, at: now)+ } else {+ _ = graph.tasks[key]?.recordApprovalRequest(from: TestFixtures.event(.approvalRequested, at: now))+ }+ let snapshot = try #require(graph.tasks[key]?.snapshot)+ monitor.acceptFixtureGraph(graph, transitions: [.waiting(snapshot, since: now)])+ return try #require(service.lastSubmissionTaskForTesting)+ }++ func resolveWaiting(keepsNonblockingQuestion: Bool = false) throws {+ graph.tasks[key]?.executions[owner]?.approval = nil+ graph.tasks[key]?.executions[owner]?.presentation = try keepsNonblockingQuestion ? question(blocking: false, at: Date()) : nil+ graph.tasks[key]?.state = .running+ monitor.acceptFixtureGraph(graph)+ }++ func cleanUp() {+ delivery.cancelPendingSubmissions()+ preferences.remove()+ try? directory.remove()+ }++ private func question(blocking: Bool, at date: Date) throws -> ActivityLivePresentation {+ var presentation = ActivityLivePresentation()+ let input = try TestFixtures.decode(ActivityInput.self, """+ {"id":"input","method":"item/tool/requestUserInput","params":{"threadId":"thread-a","turnId":"turn-a","isBlocking":\(blocking)}}+ """)+ presentation.consume(input, at: date)+ return presentation+ }+}++private final class TestNotificationDelivery {+ var suspendsSubmissions = false+ var failuresRemaining = 0+ private(set) var attempts: [String] = []+ private(set) var delivered = Set<String>()+ private(set) var removals: [Set<String>] = []+ private var pending: CheckedContinuation<Void, any Error>?++ var hasPendingSubmission: Bool {+ pending != nil+ }++ var client: NotificationService.Delivery {+ NotificationService.Delivery(+ setDelegate: { _ in },+ add: { [self] request in+ attempts.append(request.identifier)+ if suspendsSubmissions {+ try await withCheckedThrowingContinuation { pending = $0 }+ }+ if failuresRemaining > 0 {+ failuresRemaining -= 1+ throw CocoaError(.fileWriteUnknown)+ }+ delivered.insert(request.identifier)+ },+ remove: { [self] identifiers in+ removals.append(Set(identifiers))+ delivered.subtract(identifiers)+ }+ )+ }++ func resumeSubmission() {+ let continuation = pending+ pending = nil+ continuation?.resume()+ }++ func cancelPendingSubmissions() {+ suspendsSubmissions = false+ failuresRemaining = 2+ let continuation = pending+ pending = nil+ continuation?.resume(throwing: CancellationError())+ }+}