CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
feat: 添加 Codex 实时任务状态
Bob43da06ae4d4e
diff --git a/AGENTS.md b/AGENTS.mdindex 014e325..c77ca79 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -97,7 +97,7 @@ Scripts/appcast.sh## Hook、同步与数据文件- Hook 子进程入口在 `CodexBarApp.init()` 中最先调用 `WorkflowHookEventRecorder.handleIfRequested()`;Hook 模式要快速读取 stdin 并退出,不进入普通 App 启动流程。-- CodexBar 只追加或移除属于当前 CodexBar 可执行文件的 Hook 处理器,不应删除用户已有的其他 Codex Hook。+- CodexBar 只追加或移除属于当前 CodexBar 可执行文件的 Hook,不应删除用户已有的其他 Codex Hook。- 本机 Hook 事件默认写入:```textdiff --git a/CodexBar.xcodeproj/project.pbxproj b/CodexBar.xcodeproj/project.pbxprojindex cad1190..4cbaf84 100644--- a/CodexBar.xcodeproj/project.pbxproj+++ b/CodexBar.xcodeproj/project.pbxproj@@ -282,7 +282,7 @@"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";CODE_SIGN_STYLE = Automatic;COMBINE_HIDPI_IMAGES = YES;- CURRENT_PROJECT_VERSION = 38;+ CURRENT_PROJECT_VERSION = 39;DEAD_CODE_STRIPPING = YES;DEVELOPMENT_TEAM = 4KJ362VJW5;ENABLE_APP_INTENTS_METADATA_GENERATION = NO;@@ -298,7 +298,7 @@"$(inherited)","@executable_path/../Frameworks",);- MARKETING_VERSION = 3.3.0;+ MARKETING_VERSION = 3.3.1;PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar;PRODUCT_NAME = "$(TARGET_NAME)";REGISTER_APP_GROUPS = YES;@@ -321,7 +321,7 @@"CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development";CODE_SIGN_STYLE = Automatic;COMBINE_HIDPI_IMAGES = YES;- CURRENT_PROJECT_VERSION = 38;+ CURRENT_PROJECT_VERSION = 39;DEAD_CODE_STRIPPING = YES;DEVELOPMENT_TEAM = 4KJ362VJW5;ENABLE_APP_INTENTS_METADATA_GENERATION = NO;@@ -337,7 +337,7 @@"$(inherited)","@executable_path/../Frameworks",);- MARKETING_VERSION = 3.3.0;+ MARKETING_VERSION = 3.3.1;PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar;PRODUCT_NAME = "$(TARGET_NAME)";PROVISIONING_PROFILE_SPECIFIER = "";diff --git a/CodexBar/Controllers/StatusItemController.swift b/CodexBar/Controllers/StatusItemController.swiftindex 00f98de..c111350 100644--- a/CodexBar/Controllers/StatusItemController.swift+++ b/CodexBar/Controllers/StatusItemController.swift@@ -9,6 +9,7 @@ final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {lazy var viewModel = CodexStatusViewModel(service: codexStatusService)let workflowViewModel = WorkflowViewModel()lazy var codexHookSettings = CodexHookSettings(codexStatusService: codexStatusService)+ lazy var activityMonitor = CodexActivityMonitor(codexHookSettings: codexHookSettings)let syncSettings = WorkflowSyncSettings()let globalHotKeySettings = GlobalHotKeySettings()let menuBarQuotaSettings = MenuBarQuotaSettings()@@ -23,6 +24,7 @@ final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {viewModel: viewModel,workflowViewModel: workflowViewModel,codexHookSettings: codexHookSettings,+ activityMonitor: activityMonitor,syncSettings: syncSettings,globalHotKeySettings: globalHotKeySettings,menuBarQuotaSettings: menuBarQuotaSettings,@@ -35,16 +37,18 @@ final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {let notificationService = CodexNotificationService(settings: notificationSettings,statusViewModel: viewModel,- codexHookSettings: codexHookSettings+ activityMonitor: activityMonitor) { [weak controller] incontroller?.openMenuSurfaceFromNotification()}notificationService.start()self.notificationService = notificationService+ activityMonitor.start()}func applicationWillTerminate(_: Notification) {statusItemController?.uninstall()+ activityMonitor.stop()}func openSettingsFromCommand() {@@ -58,6 +62,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {private let viewModel: CodexStatusViewModelprivate let workflowViewModel: WorkflowViewModelprivate let codexHookSettings: CodexHookSettings+ private let activityMonitor: CodexActivityMonitorprivate let syncSettings: WorkflowSyncSettingsprivate let globalHotKeySettings: GlobalHotKeySettingsprivate let menuBarQuotaSettings: MenuBarQuotaSettings@@ -129,6 +134,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {private var cancellables = Set<AnyCancellable>()private var statusIconState: StatusIconState?private var statusIconAnimationTask: Task<Void, Never>?+ private var statusToolTipTask: Task<Void, Never>?private var registeredHotKeyShortcut: GlobalHotKeyShortcut?private var auxiliaryWindowFocusRestoreTask: Task<Void, Never>?private var activeStatusItemMenu: NSMenu?@@ -138,6 +144,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {viewModel: CodexStatusViewModel,workflowViewModel: WorkflowViewModel,codexHookSettings: CodexHookSettings,+ activityMonitor: CodexActivityMonitor,syncSettings: WorkflowSyncSettings,globalHotKeySettings: GlobalHotKeySettings,menuBarQuotaSettings: MenuBarQuotaSettings,@@ -147,6 +154,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {self.viewModel = viewModelself.workflowViewModel = workflowViewModelself.codexHookSettings = codexHookSettings+ self.activityMonitor = activityMonitorself.syncSettings = syncSettingsself.globalHotKeySettings = globalHotKeySettingsself.menuBarQuotaSettings = menuBarQuotaSettings@@ -155,8 +163,10 @@ private final class StatusItemController: NSObject, NSMenuDelegate {super.init()}+ /// tint 为 nil 时使用模板渲染,由系统按菜单栏外观着色。private static func makeStatusImage(_ symbolName: String,+ tint: NSColor?,progress: StatusIconProgress? = nil,progressVisibility: CGFloat = 1) -> NSImage? {@@ -164,13 +174,12 @@ private final class StatusItemController: NSObject, NSMenuDelegate {return nil}- let usesTemplateRendering = progress == nillet resolvedProgressVisibility = clampedProgressVisibility(progressVisibility)let statusImage = NSImage(size: Metrics.progressStatusImageSize, flipped: false) { _ inSelf.drawStatusSymbol(symbolImage,in: Metrics.progressStatusSymbolRect,- tint: usesTemplateRendering ? .black : .labelColor,+ tint: tint ?? .black,alpha: progress?.isStale == true ? Metrics.staleIconAlpha : 1)if let progress {@@ -181,7 +190,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {}return true}- statusImage.isTemplate = usesTemplateRendering+ statusImage.isTemplate = tint == nilstatusImage.alignmentRect = Self.statusImageAlignmentRect(for: symbolImage)return statusImage}@@ -279,13 +288,119 @@ private final class StatusItemController: NSObject, NSMenuDelegate {private struct StatusIconState: Equatable {let usesErrorImage: Boollet progress: StatusIconProgress?+ let activity: CodexActivitySnapshotvar symbolName: String {usesErrorImage ? Metrics.errorStatusSymbolName : Metrics.normalStatusSymbolName}- var toolTip: String? {- progress?.toolTip+ var tint: StatusIconTint {+ guard !usesErrorImage else {+ return .red+ }++ switch activity.primaryActivity {+ case .waiting:+ return .orange+ case .running:+ return .blue+ case .completed(_, highlighted: true):+ return .green+ case .completed, .idle:+ return .label+ }+ }++ /// nil 表示模板渲染,由系统按菜单栏外观着色。+ var renderTint: NSColor? {+ tint == .label && progress == nil ? nil : tint.color+ }++ /// 只包含影响图像像素的字段;tooltip 文本变化不应触发重绘。+ var renderState: StatusIconRenderState {+ StatusIconRenderState(symbolName: symbolName, tint: tint, progress: progress)+ }++ var hasLiveDuration: Bool {+ activity.hasActiveTasks+ }++ func toolTip(at now: Date) -> String? {+ var lines: [String] = []+ if usesErrorImage {+ lines.append("Codex 账号异常")+ }++ if let activityText = activityToolTip(at: now) {+ lines.append(activityText)+ }+ if activity.activeCount > 1 {+ lines.append("等待 \(activity.waitingCount) • 运行 \(activity.runningCount)")+ }+ if let progress {+ lines.append(progress.toolTip)+ }+ return lines.isEmpty ? nil : lines.joined(separator: "\n")+ }++ private func activityToolTip(at now: Date) -> String? {+ switch activity.primaryActivity {+ case let .waiting(task):+ var text = "Codex 等待批准"+ if let projectName = task.projectName {+ text += " • \(projectName)"+ }+ if let toolName = task.toolName {+ text += " • \(toolName)"+ }+ text += " • 已等待 \(CodexActivityDurationFormat.text(for: now.timeIntervalSince(task.stateChangedAt)))"+ return text+ case let .running(task):+ var text = "Codex 正在运行"+ if let projectName = task.projectName {+ text += " • \(projectName)"+ }+ if task.showsPreciseDuration, let startedAt = task.startedAt {+ text += " • 已运行 \(CodexActivityDurationFormat.text(for: now.timeIntervalSince(startedAt)))"+ }+ return text+ case .completed(let completion, highlighted: true):+ var text = "Codex 刚刚完成"+ if let projectName = completion.projectName {+ text += " • \(projectName)"+ }+ if let duration = completion.duration {+ text += " • 耗时 \(CodexActivityDurationFormat.text(for: duration))"+ }+ return text+ case .completed, .idle:+ return nil+ }+ }+ }++ /// 状态图标中影响像素的渲染子状态,用于跳过 tooltip-only 变化引发的重绘。+ private struct StatusIconRenderState: Equatable {+ let symbolName: String+ let tint: StatusIconTint+ let progress: StatusIconProgress?+ }++ private enum StatusIconTint: Equatable {+ case label+ case blue+ case orange+ case green+ case red++ var color: NSColor {+ switch self {+ case .label: .labelColor+ case .blue: .systemBlue+ case .orange: .systemOrange+ case .green: .systemGreen+ case .red: .systemRed+ }}}@@ -329,6 +444,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {closeMenuSurface(animated: false)auxiliaryWindowFocusRestoreTask?.cancel()statusIconAnimationTask?.cancel()+ statusToolTipTask?.cancel()workflowSyncScheduler.cancel()setAuxiliaryWindowKeyFocus(true)globalHotKeyController.uninstall()@@ -375,6 +491,7 @@ private final class StatusItemController: NSObject, NSMenuDelegate {viewModel: viewModel,workflowViewModel: workflowViewModel,codexHookSettings: codexHookSettings,+ activityMonitor: activityMonitor,syncSettings: syncSettings,menuSurfaceVisibility: menuSurfaceVisibility,onUsageHeatmapHoverChange: { [weak self] context in@@ -395,15 +512,17 @@ private final class StatusItemController: NSObject, NSMenuDelegate {}private func observeViewModel() {- Publishers.CombineLatest3(+ Publishers.CombineLatest4(viewModel.$loadState,viewModel.$snapshot,- menuBarQuotaSettings.$selection+ menuBarQuotaSettings.$selection,+ activityMonitor.$snapshot)- .map { loadState, snapshot, selection in+ .map { loadState, snapshot, selection, activity inStatusIconState(usesErrorImage: loadState.isError || snapshot?.hasTrustedData == false,- progress: StatusIconProgress(snapshot: snapshot, selection: selection)+ progress: StatusIconProgress(snapshot: snapshot, selection: selection),+ activity: activity)}.removeDuplicates()@@ -494,64 +613,56 @@ private final class StatusItemController: NSObject, NSMenuDelegate {}private func updateStatusImage(_ state: StatusIconState) {- statusItem.button?.toolTip = state.toolTip+ statusItem.button?.toolTip = state.toolTip(at: Date())guard state != statusIconState else {return}let previousState = statusIconState- statusIconAnimationTask?.cancel()statusIconState = state+ if previousState?.hasLiveDuration != state.hasLiveDuration {+ configureStatusToolTipRefresh(for: state)+ }guard let previousState else {- statusItem.button?.image = Self.makeStatusImage(state.symbolName, progress: state.progress)+ statusIconAnimationTask?.cancel()+ renderStatusImage(state)return}+ // tooltip-only 变化不重绘,也不打断进行中的图标动画。+ guard previousState.renderState != state.renderState else {+ return+ }+ statusIconAnimationTask?.cancel()- if let animation = statusProgressAnimation(- from: previousState.progress,- to: state.progress- ) {- animateStatusProgress(- symbolName: state.symbolName,- progress: animation.progress,- finalState: state,- fromVisibility: animation.fromVisibility,- toVisibility: animation.toVisibility- )+ let progressVisibilityChanged = (previousState.progress == nil) != (state.progress == nil)+ if previousState.tint != state.tint || progressVisibilityChanged {+ animateStatusImage(from: previousState, to: state)return}- statusItem.button?.image = Self.makeStatusImage(state.symbolName, progress: state.progress)+ renderStatusImage(state)}- private func statusProgressAnimation(- from previousProgress: StatusIconProgress?,- to progress: StatusIconProgress?- ) -> (progress: StatusIconProgress, fromVisibility: CGFloat, toVisibility: CGFloat)? {- switch (previousProgress, progress) {- case (nil, let progress?):- (progress, 0, 1)- case (let progress?, nil):- (progress, 1, 0)- default:- nil- }+ private func renderStatusImage(_ state: StatusIconState) {+ statusItem.button?.image = Self.makeStatusImage(+ state.symbolName,+ tint: state.renderTint,+ progress: state.progress+ )}- private func animateStatusProgress(- symbolName: String,- progress: StatusIconProgress,- finalState: StatusIconState,- fromVisibility: CGFloat,- toVisibility: CGFloat- ) {+ private func animateStatusImage(from previousState: StatusIconState, to finalState: StatusIconState) {+ let renderedProgress = finalState.progress ?? previousState.progress+ let fromVisibility: CGFloat = previousState.progress == nil ? 0 : 1+ let toVisibility: CGFloat = finalState.progress == nil ? 0 : 1+statusIconAnimationTask = Task { @MainActor [weak self] infor frame in 0 ... Metrics.statusIconProgressAnimationFrameCount {guard let self,!Task.isCancelled,- statusIconState == finalState else {+ statusIconState?.renderState == finalState.renderState else {return}@@ -559,8 +670,13 @@ private final class StatusItemController: NSObject, NSMenuDelegate {let easedProgress = Self.easedProgressVisibility(rawProgress)let visibility = fromVisibility + (toVisibility - fromVisibility) * easedProgressstatusItem.button?.image = Self.makeStatusImage(- symbolName,- progress: progress,+ finalState.symbolName,+ tint: Self.interpolatedStatusTint(+ from: previousState.tint.color,+ to: finalState.tint.color,+ progress: easedProgress+ ),+ progress: renderedProgress,progressVisibility: visibility)@@ -573,15 +689,46 @@ private final class StatusItemController: NSObject, NSMenuDelegate {guard let self,!Task.isCancelled,- statusIconState == finalState else {+ statusIconState?.renderState == finalState.renderState else {return}- statusItem.button?.image = Self.makeStatusImage(symbolName, progress: finalState.progress)+ renderStatusImage(finalState)statusIconAnimationTask = nil}}+ private func configureStatusToolTipRefresh(for state: StatusIconState) {+ statusToolTipTask?.cancel()+ statusToolTipTask = nil+ guard state.hasLiveDuration else {+ return+ }++ statusToolTipTask = Task { @MainActor [weak self] in+ while !Task.isCancelled {+ try? await Task.sleep(for: .seconds(60))+ guard let self,+ !Task.isCancelled,+ let state = statusIconState,+ state.hasLiveDuration else {+ return+ }+ statusItem.button?.toolTip = state.toolTip(at: Date())+ }+ }+ }++ private static func interpolatedStatusTint(+ from source: NSColor,+ to destination: NSColor,+ progress: CGFloat+ ) -> NSColor {+ let progress = clampedProgressVisibility(progress)+ return source.blended(withFraction: progress, of: destination)+ ?? (progress < 0.5 ? source : destination)+ }+@objc private func statusItemClicked(_ sender: NSStatusBarButton) {guard let event = NSApplication.shared.currentEvent else {toggleMenuSurface(relativeTo: sender)diff --git a/CodexBar/Models/CodexActivityModels.swift b/CodexBar/Models/CodexActivityModels.swiftnew file mode 100644index 0000000..d6e0bcc--- /dev/null+++ b/CodexBar/Models/CodexActivityModels.swift@@ -0,0 +1,108 @@+import Foundation++/// 活跃任务最近收到的 Hook 事件,供活动卡片展示当前执行阶段。+nonisolated enum CodexActivityEvent: Equatable, Sendable {+ case promptSubmitted+ case toolStarted+ case toolFinished+ case compactionStarted+ case compactionFinished+ case subagentStarted+ case subagentFinished+ case approvalRequested+}++/// bootstrap 后需要向更早日期定向查找 Prompt 起点的精确任务引用。+nonisolated struct CodexActivityPromptReference: Hashable, Sendable {+ let sessionId: String+ let turnId: String+}++/// 正在运行或等待批准的任务摘要,不对 UI 暴露原始会话 ID。+nonisolated struct CodexActivityTaskSnapshot: Equatable, Sendable {+ let latestEvent: CodexActivityEvent+ let projectName: String?+ let modelName: String?+ let toolName: String?+ let startedAt: Date?+ let stateChangedAt: Date+ let showsPreciseDuration: Bool+}++/// 最近确认结束的任务。完成只表示一轮任务结束,不代表执行成功。+nonisolated struct CodexActivityCompletion: Equatable, Identifiable, Sendable {+ let id: String+ let projectName: String?+ let completedAt: Date+ let duration: TimeInterval?+}++/// UI 只消费该快照,不直接读取或解释 Hook 事件。+nonisolated struct CodexActivitySnapshot: Equatable, Sendable {+ let primaryWaitingTask: CodexActivityTaskSnapshot?+ let primaryRunningTask: CodexActivityTaskSnapshot?+ let mostRecentCompletion: CodexActivityCompletion?+ let waitingCount: Int+ let runningCount: Int+ let isCompletionHighlighted: Bool++ static let empty = CodexActivitySnapshot(+ primaryWaitingTask: nil,+ primaryRunningTask: nil,+ mostRecentCompletion: nil,+ waitingCount: 0,+ runningCount: 0,+ isCompletionHighlighted: false+ )++ var activeCount: Int {+ waitingCount + runningCount+ }++ var hasActiveTasks: Bool {+ activeCount > 0+ }++ /// 等待批准 > 运行中 > 最近完成 > 空闲;菜单栏图标、tooltip 和活动卡片共用同一判定。+ var primaryActivity: CodexPrimaryActivity {+ if let task = primaryWaitingTask {+ return .waiting(task)+ }+ if let task = primaryRunningTask {+ return .running(task)+ }+ if let completion = mostRecentCompletion {+ return .completed(completion, highlighted: isCompletionHighlighted)+ }+ return .idle+ }+}++/// 快照归一后的主活动状态,highlighted 表示完成仍处于高亮时间窗内。+nonisolated enum CodexPrimaryActivity: Equatable, Sendable {+ case waiting(CodexActivityTaskSnapshot)+ case running(CodexActivityTaskSnapshot)+ case completed(CodexActivityCompletion, highlighted: Bool)+ case idle+}++/// 只有 live Hook 或 session 生命周期会发布 transition,bootstrap 永远不会触发历史通知。+nonisolated enum CodexActivityTransition: Equatable, Sendable {+ case waitingApproval(CodexActivityTaskSnapshot)+ case completed(CodexActivityCompletion)+}++nonisolated enum CodexActivityDurationFormat {+ static func text(for interval: TimeInterval) -> String {+ let totalSeconds = max(0, Int(interval.rounded()))+ let minutes = totalSeconds / 60+ let seconds = totalSeconds % 60+ if minutes >= 60 {+ return "\(minutes / 60) 小时 \(minutes % 60) 分"+ }+ if minutes > 0 {+ return "\(minutes) 分 \(seconds) 秒"+ }+ return "\(seconds) 秒"+ }+}diff --git a/CodexBar/Models/CodexWorkflowModels.swift b/CodexBar/Models/CodexWorkflowModels.swiftindex 3f8325f..df83a18 100644--- a/CodexBar/Models/CodexWorkflowModels.swift+++ b/CodexBar/Models/CodexWorkflowModels.swift@@ -32,7 +32,7 @@ private nonisolated enum WorkflowJSON {}/// hooks 进程落盘的最小事件模型, 对历史字段缺失保持宽容-nonisolated struct WorkflowHookEvent: Decodable, Equatable {+nonisolated struct WorkflowHookEvent: Decodable, Equatable, Sendable {let timestamp: Datelet name: Stringlet directoryPath: String?diff --git a/CodexBar/Services/Notifications/CodexNotificationService.swift b/CodexBar/Services/Notifications/CodexNotificationService.swiftindex dd43cc5..2e81284 100644--- a/CodexBar/Services/Notifications/CodexNotificationService.swift+++ b/CodexBar/Services/Notifications/CodexNotificationService.swift@@ -3,13 +3,12 @@ import Combineimport Foundationimport UserNotifications-/// 集中式通知服务: 订阅额度快照, 负责阈值判定、去重、重置调度与本地通知发送-/// 任务完成和等待批准通知的 Hook 事件接入见 handleHookEvents+/// 集中式通知服务: 订阅额度与实时活动,负责阈值判定、去重、重置调度与本地通知发送。@MainActorfinal class CodexNotificationService: NSObject {private let settings: NotificationSettingsprivate let statusViewModel: CodexStatusViewModel- private let codexHookSettings: CodexHookSettings+ private let activityMonitor: CodexActivityMonitorprivate let defaults: UserDefaultsprivate nonisolated let openMenuSurface: @MainActor @Sendable () -> Void@@ -25,23 +24,16 @@ final class CodexNotificationService: NSObject {/// 阈值穿越判定的会话内上一帧剩余比例, key 为 account|limitId|windowIdprivate var lastRemainingPercents: [String: Int] = [:]- private var tailReader: HookEventTailReader?-- /// 起点事件配对表: 优先 session|turn 精确配对, 回退 session 最近一条- private var promptTimesByTurn: [String: Date] = [:]- private var promptTimesBySession: [String: Date] = [:]- private var taskWaitingNotificationTimesByKey: [String: Date] = [:]-init(settings: NotificationSettings,statusViewModel: CodexStatusViewModel,- codexHookSettings: CodexHookSettings,+ activityMonitor: CodexActivityMonitor,defaults: UserDefaults = .standard,openMenuSurface: @escaping @MainActor @Sendable () -> Void) {self.settings = settingsself.statusViewModel = statusViewModel- self.codexHookSettings = codexHookSettings+ self.activityMonitor = activityMonitorself.defaults = defaultsself.openMenuSurface = openMenuSurfacependingResetReminders = Self.loadPendingResetReminders(from: defaults)@@ -79,136 +71,33 @@ final class CodexNotificationService: NSObject {}.store(in: &cancellables)- // 两类 Hook 通知任一开启, 且总开关、授权和 Hook 状态满足时运行 tail- Publishers.CombineLatest(- Publishers.CombineLatest4(- settings.$isEnabled,- settings.$isLongTaskEnabled,- settings.$isTaskWaitingEnabled,- settings.$authorizationStatus- ),- codexHookSettings.$isEnabled- )- .map { notificationState, hook in- let (enabled, longTask, taskWaiting, authorizationStatus) = notificationState- return enabled- && (longTask || taskWaiting)- && authorizationStatus != .denied- && hook- }- .removeDuplicates()- .sink { [weak self] shouldRun in- self?.setTailReaderActive(shouldRun)- }- .store(in: &cancellables)-- // 等待批准通知仍在运行 tail 时, 关闭任务完成通知也要立即丢弃未完成的计时配对- settings.$isLongTaskEnabled- .removeDuplicates()- .sink { [weak self] enabled in- guard !enabled else {- return- }- self?.promptTimesByTurn.removeAll()- self?.promptTimesBySession.removeAll()+ activityMonitor.transitionPublisher+ .sink { [weak self] transition in+ self?.handleActivityTransition(transition)}.store(in: &cancellables)}// MARK: - Hook 任务通知- private func setTailReaderActive(_ active: Bool) {- if active {- guard tailReader == nil else {- return- }-- let reader = HookEventTailReader { [weak self] events in- self?.handleHookEvents(events)- }- reader.start()- tailReader = reader+ private func handleActivityTransition(_ transition: CodexActivityTransition) {+ guard settings.canDeliver else {return}- tailReader?.stop()- tailReader = nil- promptTimesByTurn.removeAll()- promptTimesBySession.removeAll()- taskWaitingNotificationTimesByKey.removeAll()- }-- private func handleHookEvents(_ events: [WorkflowHookEvent]) {- for event in events {- switch event.hookEvent {- case .userPromptSubmit:- guard settings.isLongTaskEnabled,- let sessionId = event.sessionId else {- continue- }- promptTimesBySession[sessionId] = event.timestamp- if let turnId = event.turnId {- promptTimesByTurn[Self.hookTurnKey(sessionId: sessionId, turnId: turnId)] = event.timestamp- }- case .stop:- guard settings.isLongTaskEnabled,- let sessionId = event.sessionId else {- continue- }- notifyLongTaskIfNeeded(stopEvent: event, sessionId: sessionId)- case .permissionRequest:- notifyTaskWaitingIfNeeded(event)- default:- continue+ switch transition {+ case let .waitingApproval(task):+ guard settings.isTaskWaitingEnabled else {+ return}- }-- pruneHookNotificationState()- }-- private func notifyTaskWaitingIfNeeded(_ event: WorkflowHookEvent) {- guard settings.isTaskWaitingEnabled else {- return- }-- let key = Self.taskWaitingNotificationKey(for: event)- guard taskWaitingNotificationTimesByKey[key] == nil else {- return- }- taskWaitingNotificationTimesByKey[key] = event.timestamp-- send(.taskWaiting(project: event.projectDisplayName, toolName: event.toolName))- }-- private func notifyLongTaskIfNeeded(stopEvent event: WorkflowHookEvent, sessionId: String) {- let turnStart = event.turnId.flatMap {- promptTimesByTurn.removeValue(- forKey: Self.hookTurnKey(sessionId: sessionId, turnId: $0)- )- }- let start = turnStart ?? promptTimesBySession[sessionId]-- // 一条 Stop 只配对一次, 防止后续无提交的 Stop 重复计时- promptTimesBySession.removeValue(forKey: sessionId)-- guard let start else {- return- }-- let duration = event.timestamp.timeIntervalSince(start)- guard duration >= TimeInterval(settings.longTaskThresholdSeconds) else {- return- }-- send(.taskCompleted(project: event.projectDisplayName, duration: duration))- }-- private func pruneHookNotificationState() {- let cutoff = Date().addingTimeInterval(-Self.promptRetention)- promptTimesBySession = promptTimesBySession.filter { $0.value > cutoff }- promptTimesByTurn = promptTimesByTurn.filter { $0.value > cutoff }- taskWaitingNotificationTimesByKey = taskWaitingNotificationTimesByKey.filter {- $0.value > cutoff+ send(.taskWaiting(project: task.projectName, toolName: task.toolName))+ case let .completed(completion):+ guard settings.isLongTaskEnabled,+ let duration = completion.duration,+ duration >= TimeInterval(settings.longTaskThresholdSeconds) else {+ return+ }+ send(.taskCompleted(project: completion.projectName, duration: duration))}}@@ -510,10 +399,6 @@ final class CodexNotificationService: NSObject {Int(date.timeIntervalSince1970)}- private nonisolated static func hookTurnKey(sessionId: String, turnId: String) -> String {- "\(sessionId)|\(turnId)"- }-private nonisolated static func quotaWindowStateKey(accountKey: String,limitId: String,@@ -522,16 +407,6 @@ final class CodexNotificationService: NSObject {"\(accountKey)|\(limitId)|\(windowId)"}- private nonisolated static func taskWaitingNotificationKey(for event: WorkflowHookEvent) -> String {- let milliseconds = Int64((event.timestamp.timeIntervalSince1970 * 1000).rounded())- return [- String(milliseconds),- event.sessionId ?? "",- event.turnId ?? "",- event.toolName ?? ""- ].joined(separator: "|")- }-private nonisolated static func creditExpiryReminderDates(for expirationDate: Date) -> [Date] {creditExpiryReminderDays.map {expirationDate.addingTimeInterval(-TimeInterval($0) * day)@@ -557,7 +432,6 @@ final class CodexNotificationService: NSObject {private nonisolated static let day: TimeInterval = 24 * 3600private nonisolated static let creditExpiryReminderDays = [7, 6, 5, 4, 3, 2, 1]private nonisolated static let creditExpiryLeadTime: TimeInterval = 7 * day- private static let promptRetention: TimeInterval = 24 * 3600private static let sentKeysLimit = 300private static let sentKeysKey = "Notification.sentKeys"private static let pendingResetRemindersKey = "Notification.pendingResetReminders"@@ -589,7 +463,7 @@ nonisolated struct CodexNotificationContent: Equatable {let projectText = project.map { "「\($0)」" } ?? "Codex"return CodexNotificationContent(title: "Codex 任务完成",- body: "\(projectText) 任务完成, 耗时 \(durationText(duration))"+ body: "\(projectText) 任务完成, 耗时 \(CodexActivityDurationFormat.text(for: duration))")}@@ -608,21 +482,6 @@ nonisolated struct CodexNotificationContent: Equatable {body: "有 \(count) 个重置次数将于 \(CodexDateFormat.localDisplayString(from: expirationDate)) 过期")}-- private static func durationText(_ interval: TimeInterval) -> String {- let totalSeconds = Int(interval.rounded())- let minutes = totalSeconds / 60- let seconds = totalSeconds % 60- if minutes >= 60 {- return "\(minutes / 60) 小时 \(minutes % 60) 分"- }-- if minutes > 0 {- return "\(minutes) 分 \(seconds) 秒"- }-- return "\(seconds) 秒"- }}// MARK: - UNUserNotificationCenterDelegatediff --git a/CodexBar/Services/Notifications/HookEventTailReader.swift b/CodexBar/Services/Notifications/HookEventTailReader.swiftdeleted file mode 100644index 524050a..0000000--- a/CodexBar/Services/Notifications/HookEventTailReader.swift+++ /dev/null@@ -1,100 +0,0 @@-import Foundation--/// 只读 tail 读取 HookEvents/events 目录: 轮询当日 JSONL 文件大小,-/// 增量解码新追加的完整事件行后回调-/// 仅服务于通知判定, 不参与统计维护; 任何读取失败都静默跳过本轮-@MainActor-final class HookEventTailReader {- private let onEvents: ([WorkflowHookEvent]) -> Void- private var pollTask: Task<Void, Never>?- private var activeDateKey = ""- private var activeFileOffset: UInt64 = 0-- init(onEvents: @escaping ([WorkflowHookEvent]) -> Void) {- self.onEvents = onEvents- }-- func start() {- guard pollTask == nil else {- return- }-- // 初始位点取当天文件当前大小: 只处理启动之后写入的事件, 不回放历史- activeDateKey = WorkflowStorage.dateKey(for: Date())- activeFileOffset = WorkflowStorage.fileSize(at: activeFileURL)-- pollTask = Task { @MainActor [weak self] in- while !Task.isCancelled {- try? await Task.sleep(for: .seconds(Self.pollInterval))- guard let self, !Task.isCancelled else {- return- }-- drainNewLines()- }- }- }-- func stop() {- pollTask?.cancel()- pollTask = nil- }-- private var activeFileURL: URL {- WorkflowStorage.eventLogURL(for: activeDateKey)- }-- private func drainNewLines() {- let todayKey = WorkflowStorage.dateKey(for: Date())- if todayKey != activeDateKey {- // 跨零点: 先清掉旧文件尾部, 再从新文件头开始- readAppendedLines()- activeDateKey = todayKey- activeFileOffset = 0- }-- readAppendedLines()- }-- private func readAppendedLines() {- let url = activeFileURL- let size = WorkflowStorage.fileSize(at: url)- if size < activeFileOffset {- // 文件被截断或替换, 从当前头部重新开始- activeFileOffset = 0- }-- guard size > activeFileOffset,- let handle = try? FileHandle(forReadingFrom: url) else {- return- }-- defer {- try? handle.close()- }-- guard (try? handle.seek(toOffset: activeFileOffset)) != nil,- let data = try? handle.readToEnd(),- !data.isEmpty else {- return- }-- // 只消费到最后一个完整行, 半行留待下一轮- guard let lastNewlineIndex = data.lastIndex(of: Self.newlineByte) else {- return- }-- let completeData = data[...lastNewlineIndex]- activeFileOffset += UInt64(completeData.count)-- let events = JSONLines.decode(WorkflowHookEvent.self, from: completeData)- guard !events.isEmpty else {- return- }-- onEvents(events)- }-- private static let pollInterval: TimeInterval = 2- private static let newlineByte: UInt8 = 0x0A-}diff --git a/CodexBar/Services/Workflow/CodexActivityMonitor.swift b/CodexBar/Services/Workflow/CodexActivityMonitor.swiftnew file mode 100644index 0000000..27d9780--- /dev/null+++ b/CodexBar/Services/Workflow/CodexActivityMonitor.swift@@ -0,0 +1,823 @@+import AppKit+import Combine+import Foundation++/// 从本机 Hook JSONL 维护进程内实时任务状态,是菜单栏、活动卡片和通知的唯一任务状态来源。+@MainActor+final class CodexActivityMonitor: ObservableObject {+ @Published private(set) var snapshot = CodexActivitySnapshot.empty++ var transitionPublisher: AnyPublisher<CodexActivityTransition, Never> {+ transitionSubject.eraseToAnyPublisher()+ }++ private let codexHookSettings: CodexHookSettings+ private let sessionLifecycleReader = CodexSessionLifecycleReader()+ private let transitionSubject = PassthroughSubject<CodexActivityTransition, Never>()+ private var tasks: [CodexActivityTaskKey: CodexActivityTask] = [:]+ private var completions: [CodexActivityCompletion] = []+ private var recentlyCompletedTaskAt: [CodexActivityTaskKey: Date] = [:]+ private var tailReader: HookEventTailReader?+ private var tailReaderControlTask: Task<Void, Never>?+ private var tailReaderGeneration: UInt64 = 0+ private var sessionLifecyclePollTask: Task<Void, Never>?+ private var cleanupTask: Task<Void, Never>?+ private var cleanupDeadline: Date?+ private var cancellables = Set<AnyCancellable>()+ private var isStarted = false+ private var isBootstrapping = false+ private var sessionTransitionNotBefore: Date?++ init(codexHookSettings: CodexHookSettings) {+ self.codexHookSettings = codexHookSettings+ }++ func start() {+ guard !isStarted else {+ return+ }+ isStarted = true++ codexHookSettings.$isEnabled+ .removeDuplicates()+ .sink { [weak self] isEnabled in+ self?.setMonitoringEnabled(isEnabled)+ }+ .store(in: &cancellables)++ NSWorkspace.shared.notificationCenter+ .publisher(for: NSWorkspace.didWakeNotification)+ .receive(on: DispatchQueue.main)+ .sink { [weak self] _ in+ guard let self else {+ return+ }+ if let reader = tailReader {+ Task {+ await reader.drainNow()+ }+ }+ refreshSessionLifecycleNow(resetsResolutionFallbacks: true)+ }+ .store(in: &cancellables)+ }++ func stop() {+ guard isStarted else {+ return+ }+ isStarted = false+ cancellables.removeAll()+ stopReaderAndClearState()+ }++ private func setMonitoringEnabled(_ enabled: Bool) {+ guard enabled else {+ stopReaderAndClearState()+ return+ }++ guard tailReader == nil else {+ return+ }++ tailReaderGeneration &+= 1+ let generation = tailReaderGeneration+ let reader = HookEventTailReader(+ onBatch: { [weak self] batch in+ guard let self, tailReaderGeneration == generation else {+ return+ }+ consume(batch)+ }+ )+ tailReader = reader+ tailReaderControlTask = Task { @MainActor [weak self] in+ await reader.start()+ guard let self,+ tailReaderGeneration == generation,+ tailReader != nil else {+ return+ }+ startSessionLifecyclePolling(generation: generation)+ }+ }++ private func stopReaderAndClearState() {+ tailReaderGeneration &+= 1+ tailReaderControlTask?.cancel()+ tailReaderControlTask = nil+ let reader = tailReader+ tailReader = nil+ if let reader {+ Task {+ await reader.stop()+ }+ }+ sessionLifecyclePollTask?.cancel()+ sessionLifecyclePollTask = nil+ cleanupTask?.cancel()+ cleanupTask = nil+ cleanupDeadline = nil+ tasks.removeAll()+ completions.removeAll()+ recentlyCompletedTaskAt.removeAll()+ isBootstrapping = false+ sessionTransitionNotBefore = nil+ snapshot = .empty+ }++ private func startSessionLifecyclePolling(generation: UInt64) {+ guard sessionLifecyclePollTask == nil else {+ return+ }++ sessionLifecyclePollTask = Task { @MainActor [weak self] in+ while !Task.isCancelled {+ guard let self else {+ return+ }+ await reconcileSessionLifecycles(generation: generation)+ try? await Task.sleep(for: .seconds(Self.sessionLifecyclePollInterval))+ }+ }+ }++ private func refreshSessionLifecycleNow(resetsResolutionFallbacks: Bool = false) {+ guard tailReader != nil else {+ return+ }+ let generation = tailReaderGeneration++ Task { @MainActor [weak self] in+ guard let self,+ tailReaderGeneration == generation else {+ return+ }+ if resetsResolutionFallbacks {+ await sessionLifecycleReader.resetResolutionFallbacks()+ }+ guard !Task.isCancelled,+ tailReaderGeneration == generation else {+ return+ }+ await reconcileSessionLifecycles(generation: generation)+ }+ }++ private func reconcileSessionLifecycles(generation: UInt64) async {+ guard generation == tailReaderGeneration,+ tailReader != nil,+ !isBootstrapping else {+ return+ }+ let references = tasks.values.compactMap(\.turnReference)+ guard !references.isEmpty else {+ return+ }+ let states = await sessionLifecycleReader.lifecycleStates(for: references)+ guard !Task.isCancelled,+ generation == tailReaderGeneration,+ tailReader != nil,+ !isBootstrapping,+ !states.isEmpty else {+ return+ }++ var didChange = false+ var transitions: [CodexActivityTransition] = []+ for state in states {+ let key = CodexActivityTaskKey.turn(session: state.sessionId, turn: state.turnId)+ guard var task = tasks[key] else {+ continue+ }++ if task.startedAt == nil,+ let startedAt = state.startedAt,+ startedAt <= task.lastActivityAt.addingTimeInterval(1) {+ task.startedAt = startedAt+ tasks[key] = task+ didChange = true+ }++ guard let terminal = state.terminal else {+ continue+ }+ switch terminal {+ case .aborted:+ tasks.removeValue(forKey: key)+ // 中断不是完成,不发布 transition,也不产生绿色状态或通知。+ didChange = true+ case let .completed(completedAt, duration):+ if recentCompletionDate(for: key) != nil {+ // 迟到事件恢复出的任务不能被 rollout 再次完成。+ tasks.removeValue(forKey: key)+ didChange = true+ continue+ }+ guard let completion = completeTask(+ key: key,+ completedAt: completedAt,+ reportedDuration: duration+ ) else {+ continue+ }+ didChange = true+ if let sessionTransitionNotBefore,+ completion.completedAt >= sessionTransitionNotBefore {+ transitions.append(.completed(completion))+ }+ }+ }++ if didChange {+ refreshSnapshot(now: Date())+ }+ for transition in transitions {+ transitionSubject.send(transition)+ }+ }++ private func consume(_ batch: HookEventBatch) {+ switch batch {+ case .bootstrapStart:+ isBootstrapping = true+ sessionTransitionNotBefore = nil+ tasks.removeAll()+ completions.removeAll()+ recentlyCompletedTaskAt.removeAll()+ case let .bootstrapEvents(events):+ for event in events {+ _ = apply(event)+ }+ case .bootstrapEnd:+ isBootstrapping = false+ sessionTransitionNotBefore = Date()+ refreshSnapshot(now: Date())+ refreshSessionLifecycleNow()+ backfillPromptStartTimesFromHistory()+ case let .live(events):+ var transitions: [CodexActivityLiveTransition] = []+ for event in events {+ if let transition = apply(event) {+ transitions.append(transition)+ }+ }++ refreshSnapshot(now: Date())+ publishLiveTransitions(transitions)+ }+ }++ /// bootstrap 只覆盖 24 小时窗口;窗口内恢复出的无起点任务向更早日期回查 Prompt 起点。+ private func backfillPromptStartTimesFromHistory() {+ let references = tasks.values.compactMap(\.promptReference)+ guard !references.isEmpty, let reader = tailReader else {+ return+ }+ let generation = tailReaderGeneration++ Task { @MainActor [weak self] in+ let startTimes = await reader.findPromptStartTimes(for: references)+ guard let self,+ tailReaderGeneration == generation,+ !isBootstrapping,+ !startTimes.isEmpty else {+ return+ }+ backfillStartTimes(startTimes)+ }+ }++ private func backfillStartTimes(_ startTimes: [CodexActivityPromptReference: Date]) {+ var didChange = false+ for (reference, startedAt) in startTimes {+ let key = CodexActivityTaskKey.turn(session: reference.sessionId, turn: reference.turnId)+ guard var task = tasks[key],+ task.startedAt == nil,+ startedAt <= task.lastActivityAt else {+ continue+ }+ task.startedAt = startedAt+ tasks[key] = task+ didChange = true+ }+ if didChange {+ refreshSnapshot(now: Date())+ }+ }++ private func apply(_ event: WorkflowHookEvent) -> CodexActivityLiveTransition? {+ switch event.hookEvent {+ case .userPromptSubmit:+ startTask(from: event)+ case .preToolUse:+ resumeTask(from: event, latestEvent: .toolStarted, allowsRecovery: true)+ case .postToolUse:+ resumeTask(from: event, latestEvent: .toolFinished, allowsRecovery: true)+ case .preCompact:+ resumeTask(from: event, latestEvent: .compactionStarted, allowsRecovery: true)+ case .postCompact:+ resumeTask(from: event, latestEvent: .compactionFinished, allowsRecovery: true)+ case .subagentStart:+ // 子智能体只更新所属顶层任务,不自行创建一条并发任务。+ resumeTask(from: event, latestEvent: .subagentStarted, allowsRecovery: false)+ case .subagentStop:+ resumeTask(from: event, latestEvent: .subagentFinished, allowsRecovery: false)+ case .permissionRequest:+ return waitForApproval(from: event)+ case .stop:+ return completeTask(from: event)+ case .sessionStart, .none:+ break+ }+ return nil+ }++ private func startTask(from event: WorkflowHookEvent) {+ let key = CodexActivityTaskKey(event: event)+ if let completedAt = recentCompletionDate(for: key),+ event.timestamp <= completedAt {+ return+ }+ if let existing = tasks[key], event.timestamp < existing.lastActivityAt {+ return+ }++ if let sessionId = key.sessionId {+ // 同一 session 的 turn 按顺序执行。新 prompt 代表旧 turn 已被中断,+ // 即使旧 turn 没有 Stop,也不能继续显示为并发运行任务。+ guard !tasks.values.contains(where: {+ $0.key.sessionId == sessionId && $0.lastActivityAt > event.timestamp+ }) else {+ return+ }+ tasks = tasks.filter { taskKey, _ in+ taskKey == key || taskKey.sessionId != sessionId+ }+ }++ recentlyCompletedTaskAt.removeValue(forKey: key)+ if let sessionId = key.sessionId {+ // 缺少 turn 的 Stop 会使用 session 键;新 turn 开始后允许该键再次完成。+ recentlyCompletedTaskAt.removeValue(forKey: .session(sessionId))+ }++ tasks[key] = CodexActivityTask(+ key: key,+ event: event,+ state: .running,+ latestEvent: .promptSubmitted,+ startedAt: event.timestamp+ )+ }++ private func resumeTask(+ from event: WorkflowHookEvent,+ latestEvent: CodexActivityEvent,+ allowsRecovery: Bool+ ) {+ let eventKey = CodexActivityTaskKey(event: event)+ guard recentCompletionDate(for: eventKey) == nil else {+ return+ }++ if let key = matchingTaskKey(for: event), var task = tasks[key] {+ guard event.timestamp >= task.lastActivityAt else {+ return+ }++ if task.state != .running {+ task.state = .running+ task.stateChangedAt = event.timestamp+ }+ task.latestEvent = latestEvent+ task.mergeMetadata(from: event)+ task.lastActivityAt = event.timestamp+ tasks[key] = task+ return+ }++ guard allowsRecovery else {+ return+ }++ tasks[eventKey] = CodexActivityTask(+ key: eventKey,+ event: event,+ state: .running,+ latestEvent: latestEvent,+ startedAt: nil+ )+ }++ private func waitForApproval(from event: WorkflowHookEvent) -> CodexActivityLiveTransition? {+ let eventKey = CodexActivityTaskKey(event: event)+ guard recentCompletionDate(for: eventKey) == nil else {+ return nil+ }++ if let key = matchingTaskKey(for: event), var task = tasks[key] {+ guard event.timestamp >= task.lastActivityAt else {+ return nil+ }++ let wasWaiting = task.state == .waitingApproval+ if !wasWaiting {+ task.state = .waitingApproval+ task.stateChangedAt = event.timestamp+ }+ task.latestEvent = .approvalRequested+ task.mergeMetadata(from: event)+ // 权限事件描述当前请求;缺失工具名时不能沿用上一条工具事件。+ task.toolName = event.toolName+ task.lastActivityAt = event.timestamp+ tasks[key] = task+ return wasWaiting ? nil : .waitingApproval(key)+ }++ let task = CodexActivityTask(+ key: eventKey,+ event: event,+ state: .waitingApproval,+ latestEvent: .approvalRequested,+ startedAt: nil+ )+ tasks[eventKey] = task+ return .waitingApproval(eventKey)+ }++ private func completeTask(from event: WorkflowHookEvent) -> CodexActivityLiveTransition? {+ let eventKey = CodexActivityTaskKey(event: event)+ guard recentCompletionDate(for: eventKey) == nil else {+ // 清掉旧版本或异常顺序留下的同键恢复任务。+ tasks.removeValue(forKey: eventKey)+ return nil+ }++ let matchedKey = matchingTaskKey(for: event)+ let task = matchedKey.flatMap { tasks[$0] }+ if let task, event.timestamp < task.lastActivityAt {+ return nil+ }++ let key = matchedKey ?? eventKey+ guard recentCompletionDate(for: key) == nil else {+ if let matchedKey {+ tasks.removeValue(forKey: matchedKey)+ }+ return nil+ }++ if let matchedKey {+ tasks.removeValue(forKey: matchedKey)+ }++ let duration = task?.preciseDuration(until: event.timestamp)++ let completion = storeCompletion(+ key: key,+ projectName: event.projectDisplayName ?? task?.projectName,+ completedAt: event.timestamp,+ duration: duration+ )+ recordCompletedTask(eventKey, at: event.timestamp)+ recordCompletedTask(key, at: event.timestamp)+ return .completed(completion)+ }++ private func completeTask(+ key: CodexActivityTaskKey,+ completedAt: Date,+ reportedDuration: TimeInterval?+ ) -> CodexActivityCompletion? {+ guard let task = tasks.removeValue(forKey: key) else {+ return nil+ }++ // rollout 时间戳是整秒,避免因为同一秒内的 Hook 毫秒时间戳而把完成时间记在最后活动之前。+ let recordedCompletedAt = max(completedAt, task.lastActivityAt)+ let duration = reportedDuration ?? task.preciseDuration(until: recordedCompletedAt)++ let completion = storeCompletion(+ key: key,+ projectName: task.projectName,+ completedAt: recordedCompletedAt,+ duration: duration+ )+ recordCompletedTask(key, at: recordedCompletedAt)+ return completion+ }++ /// 精确 turn 失败后回退同 session 最近活动,再回退同项目匿名任务。+ private func matchingTaskKey(for event: WorkflowHookEvent) -> CodexActivityTaskKey? {+ let exactKey = CodexActivityTaskKey(event: event)+ if tasks[exactKey] != nil {+ return exactKey+ }++ if let sessionId = event.sessionId,+ let match = tasks.values+ .filter({ $0.key.sessionId == sessionId })+ .max(by: { $0.lastActivityAt < $1.lastActivityAt }) {+ return match.key+ }++ let anonymousKey = CodexActivityTaskKey.anonymous(+ project: CodexActivityTaskKey.projectIdentifier(event.projectDisplayName)+ )+ return tasks[anonymousKey] == nil ? nil : anonymousKey+ }++ private func refreshSnapshot(now: Date) {+ pruneExpiredState(now: now)++ let waitingTasks = tasks.values.filter { $0.state == .waitingApproval }+ let runningTasks = tasks.values.filter { $0.state == .running }+ let mostRecentCompletion = completions.max { $0.completedAt < $1.completedAt }++ let newSnapshot = CodexActivitySnapshot(+ primaryWaitingTask: waitingTasks.max(by: { $0.lastActivityAt < $1.lastActivityAt })?.snapshot,+ primaryRunningTask: runningTasks.max(by: { $0.lastActivityAt < $1.lastActivityAt })?.snapshot,+ mostRecentCompletion: mostRecentCompletion,+ waitingCount: waitingTasks.count,+ runningCount: runningTasks.count,+ isCompletionHighlighted: mostRecentCompletion.map {+ now < $0.completedAt.addingTimeInterval(Self.completionHighlightDuration)+ } ?? false+ )+ if newSnapshot != snapshot {+ snapshot = newSnapshot+ }++ scheduleNextCleanup(now: now, mostRecentCompletion: mostRecentCompletion)+ }++ private func pruneExpiredState(now: Date) {+ let activityCutoff = now.addingTimeInterval(-Self.activityRetention)+ tasks = tasks.filter { $0.value.lastActivityAt > activityCutoff }++ let completionCutoff = now.addingTimeInterval(-Self.completionRetention)+ completions.removeAll { $0.completedAt <= completionCutoff }++ let completedTaskCutoff = now.addingTimeInterval(-Self.completedTaskRetention)+ recentlyCompletedTaskAt = recentlyCompletedTaskAt.filter {+ $0.value > completedTaskCutoff+ }+ }++ private func scheduleNextCleanup(+ now: Date,+ mostRecentCompletion: CodexActivityCompletion?+ ) {+ var deadlines = tasks.values.map {+ $0.lastActivityAt.addingTimeInterval(Self.activityRetention)+ }+ deadlines.append(contentsOf: completions.map {+ $0.completedAt.addingTimeInterval(Self.completionRetention)+ })+ deadlines.append(contentsOf: recentlyCompletedTaskAt.values.map {+ $0.addingTimeInterval(Self.completedTaskRetention)+ })+ if let mostRecentCompletion {+ let highlightDeadline = mostRecentCompletion.completedAt+ .addingTimeInterval(Self.completionHighlightDuration)+ if highlightDeadline > now {+ deadlines.append(highlightDeadline)+ }+ }++ guard let nextDeadline = deadlines.filter({ $0 > now }).min() else {+ cleanupTask?.cancel()+ cleanupTask = nil+ cleanupDeadline = nil+ return+ }+ guard cleanupTask == nil || cleanupDeadline != nextDeadline else {+ return+ }++ cleanupTask?.cancel()+ cleanupDeadline = nextDeadline+ cleanupTask = Task { @MainActor [weak self] in+ try? await Task.sleep(for: .seconds(max(0, nextDeadline.timeIntervalSinceNow)))+ guard let self, !Task.isCancelled else {+ return+ }+ cleanupTask = nil+ cleanupDeadline = nil+ refreshSnapshot(now: Date())+ }+ }++ private static let completionHighlightDuration: TimeInterval = 20+ private static let completionRetention: TimeInterval = 5 * 60+ private static let completedTaskRetention: TimeInterval = 24 * 60 * 60+ private static let activityRetention: TimeInterval = 24 * 60 * 60+ private static let sessionLifecyclePollInterval: TimeInterval = 2+}++private extension CodexActivityMonitor {+ func storeCompletion(+ key: CodexActivityTaskKey,+ projectName: String?,+ completedAt: Date,+ duration: TimeInterval?+ ) -> CodexActivityCompletion {+ let completion = CodexActivityCompletion(+ id: "\(key.identifier)|\(Int64((completedAt.timeIntervalSince1970 * 1000).rounded()))",+ projectName: projectName,+ completedAt: completedAt,+ duration: duration+ )+ completions.removeAll { $0.id == completion.id }+ completions.append(completion)+ return completion+ }++ func recentCompletionDate(+ for key: CodexActivityTaskKey,+ now: Date = Date()+ ) -> Date? {+ guard let completedAt = recentlyCompletedTaskAt[key] else {+ return nil+ }+ guard completedAt > now.addingTimeInterval(-Self.completedTaskRetention) else {+ recentlyCompletedTaskAt.removeValue(forKey: key)+ return nil+ }+ return completedAt+ }++ func recordCompletedTask(_ key: CodexActivityTaskKey, at completedAt: Date) {+ recentlyCompletedTaskAt[key] = max(+ recentlyCompletedTaskAt[key] ?? .distantPast,+ completedAt+ )+ if let sessionId = key.sessionId {+ let sessionKey = CodexActivityTaskKey.session(sessionId)+ recentlyCompletedTaskAt[sessionKey] = max(+ recentlyCompletedTaskAt[sessionKey] ?? .distantPast,+ completedAt+ )+ }+ }++ func publishLiveTransitions(_ transitions: [CodexActivityLiveTransition]) {+ var lastWaitingIndexByKey: [CodexActivityTaskKey: Int] = [:]+ for (index, transition) in transitions.enumerated() {+ if case let .waitingApproval(key) = transition {+ lastWaitingIndexByKey[key] = index+ }+ }++ var publishedCompletionIDs = Set<String>()+ for (index, transition) in transitions.enumerated() {+ switch transition {+ case let .waitingApproval(key):+ guard lastWaitingIndexByKey[key] == index,+ let task = tasks[key],+ task.state == .waitingApproval else {+ continue+ }+ transitionSubject.send(.waitingApproval(task.snapshot))+ case let .completed(completion):+ guard publishedCompletionIDs.insert(completion.id).inserted else {+ continue+ }+ transitionSubject.send(.completed(completion))+ }+ }+ }+}++private enum CodexActivityTaskKey: Hashable {+ case turn(session: String, turn: String)+ case session(String)+ case anonymous(project: String)++ init(event: WorkflowHookEvent) {+ if let sessionId = event.sessionId, let turnId = event.turnId {+ self = .turn(session: sessionId, turn: turnId)+ } else if let sessionId = event.sessionId {+ self = .session(sessionId)+ } else {+ self = .anonymous(project: Self.projectIdentifier(event.projectDisplayName))+ }+ }++ var sessionId: String? {+ switch self {+ case let .turn(session, _), let .session(session): session+ case .anonymous: nil+ }+ }++ var isAnonymous: Bool {+ if case .anonymous = self {+ return true+ }+ return false+ }++ var identifier: String {+ switch self {+ case let .turn(session, turn): "turn|\(session)|\(turn)"+ case let .session(session): "session|\(session)"+ case let .anonymous(project): "project|\(project)"+ }+ }++ static func projectIdentifier(_ project: String?) -> String {+ project ?? "__codex__"+ }+}++private enum CodexActivityLiveTransition {+ case waitingApproval(CodexActivityTaskKey)+ case completed(CodexActivityCompletion)+}++private enum CodexActivityTaskState {+ case running+ case waitingApproval+}++private struct CodexActivityTask {+ let key: CodexActivityTaskKey+ var state: CodexActivityTaskState+ var latestEvent: CodexActivityEvent+ var projectName: String?+ var modelName: String?+ var toolName: String?+ var startedAt: Date?+ var stateChangedAt: Date+ var lastActivityAt: Date++ init(+ key: CodexActivityTaskKey,+ event: WorkflowHookEvent,+ state: CodexActivityTaskState,+ latestEvent: CodexActivityEvent,+ startedAt: Date?+ ) {+ self.key = key+ self.state = state+ self.latestEvent = latestEvent+ projectName = event.projectDisplayName+ modelName = event.modelName+ toolName = event.toolName+ self.startedAt = startedAt+ stateChangedAt = event.timestamp+ lastActivityAt = event.timestamp+ }++ var showsPreciseDuration: Bool {+ startedAt != nil && !key.isAnonymous+ }++ /// 起点可信时返回到 end 的精确耗时,起点缺失或晚于 end 时为 nil。+ func preciseDuration(until end: Date) -> TimeInterval? {+ guard showsPreciseDuration, let startedAt, end >= startedAt else {+ return nil+ }+ return end.timeIntervalSince(startedAt)+ }++ var snapshot: CodexActivityTaskSnapshot {+ CodexActivityTaskSnapshot(+ latestEvent: latestEvent,+ projectName: projectName,+ modelName: modelName,+ toolName: toolName,+ startedAt: startedAt,+ stateChangedAt: stateChangedAt,+ showsPreciseDuration: showsPreciseDuration+ )+ }++ var turnReference: CodexActivityTurnReference? {+ guard case let .turn(sessionId, turnId) = key else {+ return nil+ }+ return CodexActivityTurnReference(+ sessionId: sessionId,+ turnId: turnId,+ startedAt: startedAt ?? lastActivityAt+ )+ }++ var promptReference: CodexActivityPromptReference? {+ guard startedAt == nil,+ case let .turn(sessionId, turnId) = key else {+ return nil+ }+ return CodexActivityPromptReference(sessionId: sessionId, turnId: turnId)+ }++ mutating func mergeMetadata(from event: WorkflowHookEvent) {+ projectName = event.projectDisplayName ?? projectName+ modelName = event.modelName ?? modelName+ toolName = event.toolName ?? toolName+ }+}diff --git a/CodexBar/Services/Workflow/CodexSessionLifecycleReader.swift b/CodexBar/Services/Workflow/CodexSessionLifecycleReader.swiftnew file mode 100644index 0000000..636ad0a--- /dev/null+++ b/CodexBar/Services/Workflow/CodexSessionLifecycleReader.swift@@ -0,0 +1,331 @@+import Foundation++/// 活跃 turn 的最小定位信息,只在进程内用于关联 Codex session 生命周期事件。+nonisolated struct CodexActivityTurnReference: Hashable, Sendable {+ let sessionId: String+ let turnId: String+ let startedAt: Date+}++/// 增量读取活跃 Codex session 的 rollout JSONL,只提取 turn 生命周期字段。+actor CodexSessionLifecycleReader {+ private let sessionsRootURL: URL+ private let archivedSessionsRootURL: URL+ private let fileManager: FileManager+ private var cursorsBySession: [String: SessionFileCursor] = [:]+ private var lastResolutionAttemptBySession: [String: Date] = [:]+ private var recursiveFallbackSessionIds = Set<String>()++ init(+ codexHomeURL: URL = CodexCLIResolver.codexHomeDirectory(),+ fileManager: FileManager = .default+ ) {+ sessionsRootURL = codexHomeURL.appendingPathComponent("sessions", isDirectory: true)+ archivedSessionsRootURL = codexHomeURL.appendingPathComponent(+ "archived_sessions",+ isDirectory: true+ )+ self.fileManager = fileManager+ }++ /// 返回 rollout 中已知的起点和终态,不解码会话或工具内容。+ func lifecycleStates(+ for references: [CodexActivityTurnReference]+ ) -> [CodexSessionTaskLifecycleState] {+ let referencesBySession = Dictionary(grouping: references, by: \CodexActivityTurnReference.sessionId)+ let activeSessionIds = Set(referencesBySession.keys)+ cursorsBySession = cursorsBySession.filter { activeSessionIds.contains($0.key) }+ lastResolutionAttemptBySession = lastResolutionAttemptBySession.filter {+ activeSessionIds.contains($0.key)+ }+ recursiveFallbackSessionIds.formIntersection(activeSessionIds)++ var states: [CodexSessionTaskLifecycleState] = []+ for (sessionId, sessionReferences) in referencesBySession {+ guard let reference = sessionReferences.max(by: { $0.startedAt < $1.startedAt }),+ var cursor = cursor(for: reference) else {+ continue+ }++ scanNewLifecycleEvents(into: &cursor)+ cursorsBySession[sessionId] = cursor+ for reference in sessionReferences {+ guard let lifecycle = cursor.lifecycleByTurnId[reference.turnId] else {+ continue+ }+ states.append(+ CodexSessionTaskLifecycleState(+ sessionId: reference.sessionId,+ turnId: reference.turnId,+ startedAt: lifecycle.startedAt,+ terminal: lifecycle.terminal+ )+ )+ }+ }+ return states+ }++ /// 唤醒后允许仍未定位到文件的活跃 session 重新执行一次递归兜底。+ func resetResolutionFallbacks() {+ lastResolutionAttemptBySession.removeAll()+ recursiveFallbackSessionIds.removeAll()+ }++ private func cursor(for reference: CodexActivityTurnReference) -> SessionFileCursor? {+ if let cursor = cursorsBySession[reference.sessionId],+ fileManager.fileExists(atPath: cursor.url.path) {+ return cursor+ }+ if cursorsBySession.removeValue(forKey: reference.sessionId) != nil {+ // 缓存文件可能被移动到 archived_sessions,允许重新完整定位一次。+ recursiveFallbackSessionIds.remove(reference.sessionId)+ }++ let now = Date()+ if let lastAttempt = lastResolutionAttemptBySession[reference.sessionId],+ now.timeIntervalSince(lastAttempt) < Self.fileResolutionRetryInterval {+ return nil+ }+ lastResolutionAttemptBySession[reference.sessionId] = now++ let url = locateLikelySessionFile(for: reference)+ ?? recursiveSessionFileIfNeeded(for: reference)+ guard let url else {+ return nil+ }+ lastResolutionAttemptBySession.removeValue(forKey: reference.sessionId)+ return initialCursor(for: url)+ }++ private func locateLikelySessionFile(for reference: CodexActivityTurnReference) -> URL? {+ let suffix = "-\(reference.sessionId).jsonl"+ let likelyDirectories = [+ sessionDirectory(for: reference.startedAt),+ sessionDirectory(for: Date()),+ archivedSessionsRootURL+ ]++ for directory in likelyDirectories {+ if let match = matchingFile(in: directory, suffix: suffix) {+ return match+ }+ }+ return nil+ }++ private func recursiveSessionFileIfNeeded(+ for reference: CodexActivityTurnReference+ ) -> URL? {+ guard recursiveFallbackSessionIds.insert(reference.sessionId).inserted else {+ return nil+ }++ // resume 可能继续很早以前创建的 session;每次活跃生命周期最多递归一次。+ let suffix = "-\(reference.sessionId).jsonl"+ guard let enumerator = fileManager.enumerator(+ at: sessionsRootURL,+ includingPropertiesForKeys: [.isRegularFileKey],+ options: [.skipsHiddenFiles, .skipsPackageDescendants]+ ) else {+ return nil+ }+ for case let url as URL in enumerator where url.lastPathComponent.hasSuffix(suffix) {+ return url+ }+ return nil+ }++ private func matchingFile(in directory: URL, suffix: String) -> URL? {+ guard let urls = try? fileManager.contentsOfDirectory(+ at: directory,+ includingPropertiesForKeys: nil,+ options: [.skipsHiddenFiles]+ ) else {+ return nil+ }+ return urls.first { $0.lastPathComponent.hasSuffix(suffix) }+ }++ private func sessionDirectory(for date: Date) -> URL {+ let components = Calendar.current.dateComponents([.year, .month, .day], from: date)+ return sessionsRootURL+ .appendingPathComponent(String(format: "%04d", components.year ?? 0), isDirectory: true)+ .appendingPathComponent(String(format: "%02d", components.month ?? 0), isDirectory: true)+ .appendingPathComponent(String(format: "%02d", components.day ?? 0), isDirectory: true)+ }++ private func initialCursor(for url: URL) -> SessionFileCursor {+ let stat = WorkflowStorage.fileStat(at: url)+ let size = stat?.size ?? 0+ let offset = size > Self.bootstrapByteLimit ? size - Self.bootstrapByteLimit : 0+ return SessionFileCursor(+ url: url,+ fileIdentifier: stat?.identifier,+ offset: offset,+ discardsLeadingPartialLine: offset > 0,+ lifecycleByTurnId: [:]+ )+ }++ private func scanNewLifecycleEvents(into cursor: inout SessionFileCursor) {+ let stat = WorkflowStorage.fileStat(at: cursor.url)+ let size = stat?.size ?? 0+ let identifier = stat?.identifier+ if size < cursor.offset+ || (cursor.fileIdentifier != nil && identifier != nil && cursor.fileIdentifier != identifier) {+ cursor = initialCursor(for: cursor.url)+ }++ guard size > cursor.offset,+ let handle = try? FileHandle(forReadingFrom: cursor.url) else {+ return+ }+ defer {+ try? handle.close()+ }++ guard (try? handle.seek(toOffset: cursor.offset)) != nil,+ let data = try? handle.readToEnd(),+ !data.isEmpty,+ let lastNewlineIndex = data.lastIndex(of: Self.newlineByte) else {+ return+ }++ let consumedCount = data.distance(from: data.startIndex, to: lastNewlineIndex) + 1+ cursor.offset += UInt64(consumedCount)+ cursor.fileIdentifier = identifier++ var firstCompleteIndex = data.startIndex+ if cursor.discardsLeadingPartialLine {+ firstCompleteIndex = data.index(after: data.firstIndex(of: Self.newlineByte) ?? lastNewlineIndex)+ cursor.discardsLeadingPartialLine = false+ }++ guard firstCompleteIndex <= lastNewlineIndex else {+ return+ }++ let completeData = Data(data[firstCompleteIndex ... lastNewlineIndex])+ for envelope in JSONLines.decode(CodexSessionLifecycleEnvelope.self, from: completeData) {+ guard let event = envelope.lifecycleEvent else {+ continue+ }+ var lifecycle = cursor.lifecycleByTurnId[event.turnId] ?? SessionTurnLifecycle()+ lifecycle.apply(event.change)+ cursor.lifecycleByTurnId[event.turnId] = lifecycle+ }+ }++ private static let bootstrapByteLimit: UInt64 = 512 * 1024+ private static let fileResolutionRetryInterval: TimeInterval = 10+ private static let newlineByte: UInt8 = 0x0A+}++private nonisolated struct SessionFileCursor {+ let url: URL+ var fileIdentifier: UInt64?+ var offset: UInt64+ var discardsLeadingPartialLine: Bool+ var lifecycleByTurnId: [String: SessionTurnLifecycle]+}++private nonisolated struct CodexSessionLifecycleEnvelope: Decodable {+ let type: String+ let payload: CodexSessionLifecyclePayload?++ var lifecycleEvent: SessionLifecycleEvent? {+ guard type == "event_msg",+ let payload,+ let turnId = payload.turnId,+ !turnId.isEmpty else {+ return nil+ }++ switch payload.type {+ case "task_started":+ guard let startedAt = payload.startedAt.flatMap(Self.date) else {+ return nil+ }+ return SessionLifecycleEvent(turnId: turnId, change: .started(at: startedAt))+ case "task_complete":+ guard let completedAt = payload.completedAt.flatMap(Self.date) else {+ return nil+ }+ let duration = payload.durationMilliseconds.flatMap { milliseconds in+ milliseconds.isFinite && milliseconds >= 0 ? milliseconds / 1000 : nil+ }+ return SessionLifecycleEvent(turnId: turnId, change: .completed(at: completedAt, duration: duration))+ case "turn_aborted":+ return SessionLifecycleEvent(turnId: turnId, change: .aborted)+ default:+ return nil+ }+ }++ private static func date(from seconds: Double) -> Date? {+ guard seconds.isFinite, seconds > 0 else {+ return nil+ }+ return Date(timeIntervalSince1970: seconds)+ }+}++private nonisolated struct CodexSessionLifecyclePayload: Decodable {+ let type: String?+ let turnId: String?+ let startedAt: Double?+ let completedAt: Double?+ let durationMilliseconds: Double?++ private enum CodingKeys: String, CodingKey {+ case type+ case turnId = "turn_id"+ case startedAt = "started_at"+ case completedAt = "completed_at"+ case durationMilliseconds = "duration_ms"+ }+}++private nonisolated struct SessionLifecycleEvent {+ let turnId: String+ let change: SessionLifecycleChange+}++private nonisolated enum SessionLifecycleChange {+ case started(at: Date)+ case completed(at: Date, duration: TimeInterval?)+ case aborted+}++private nonisolated struct SessionTurnLifecycle {+ var startedAt: Date?+ var terminal: CodexSessionTaskTerminalState?++ mutating func apply(_ change: SessionLifecycleChange) {+ switch change {+ case let .started(at):+ if let currentStartedAt = startedAt {+ startedAt = min(currentStartedAt, at)+ } else {+ startedAt = at+ }+ case let .completed(at, duration):+ terminal = .completed(at: at, duration: duration)+ case .aborted:+ terminal = .aborted+ }+ }+}++nonisolated struct CodexSessionTaskLifecycleState: Sendable {+ let sessionId: String+ let turnId: String+ let startedAt: Date?+ let terminal: CodexSessionTaskTerminalState?+}++nonisolated enum CodexSessionTaskTerminalState: Sendable {+ case completed(at: Date, duration: TimeInterval?)+ case aborted+}diff --git a/CodexBar/Services/Workflow/HookEventTailReader.swift b/CodexBar/Services/Workflow/HookEventTailReader.swiftnew file mode 100644index 0000000..e1cbc6f--- /dev/null+++ b/CodexBar/Services/Workflow/HookEventTailReader.swift@@ -0,0 +1,420 @@+import Foundation++nonisolated enum HookEventBatch: Sendable {+ case bootstrapStart+ case bootstrapEvents([WorkflowHookEvent])+ case bootstrapEnd+ case live([WorkflowHookEvent])+}++/// 在独立 actor 中按完整 JSONL 行读取 HookEvents/events。+/// bootstrap 覆盖滚动 24 小时并作为单次事务发送,live 随后按当日文件 offset 增量读取。+actor HookEventTailReader {+ private let onBatch: @MainActor @Sendable (HookEventBatch) -> Void+ private var pollTask: Task<Void, Never>?+ private var isRunning = false+ // actor 会在 await 期间重入;所有外部读取请求通过这两个标记合并为单一读取流程。+ private var isProcessingReads = false+ private var hasPendingDrain = false+ private var activeDateKey = ""+ private var activeFileOffset: UInt64 = 0+ private var activeFileIdentifier: UInt64?++ init(onBatch: @escaping @MainActor @Sendable (HookEventBatch) -> Void) {+ self.onBatch = onBatch+ }++ func start() async {+ guard !isRunning, !isProcessingReads else {+ return+ }+ isRunning = true+ isProcessingReads = true+ defer {+ isProcessingReads = false+ }++ await bootstrapRecentActivity()+ await drainPendingRequests()+ guard isRunning, !Task.isCancelled else {+ return+ }++ pollTask = Task { [weak self] in+ while !Task.isCancelled {+ try? await Task.sleep(for: .seconds(Self.pollInterval))+ guard !Task.isCancelled else {+ return+ }+ await self?.drainNow()+ }+ }+ }++ func stop() {+ isRunning = false+ hasPendingDrain = false+ pollTask?.cancel()+ pollTask = nil+ }++ func drainNow() async {+ guard isRunning, !Task.isCancelled else {+ return+ }+ hasPendingDrain = true++ guard !isProcessingReads else {+ return+ }+ isProcessingReads = true+ defer {+ isProcessingReads = false+ }+ await drainPendingRequests()+ }++ private func drainPendingRequests() async {+ while isRunning, hasPendingDrain, !Task.isCancelled {+ hasPendingDrain = false+ await drainNewLines()+ }+ }++ private var activeFileURL: URL {+ WorkflowStorage.eventLogURL(for: activeDateKey)+ }++ private func bootstrapRecentActivity() async {+ for _ in 0 ..< Self.bootstrapAttemptLimit {+ guard isRunning, !Task.isCancelled else {+ return+ }+ if let result = await bootstrapAttempt(now: Date()) {+ activeDateKey = result.activeDateKey+ activeFileOffset = result.activeFileOffset+ activeFileIdentifier = result.activeFileIdentifier+ await onBatch(.bootstrapEnd)+ return+ }+ }++ // 连续读取失败时清空恢复态并跳过当前已有字节,避免稍后误当 live 发送历史通知。+ let dateKey = WorkflowStorage.dateKey(for: Date())+ let stat = WorkflowStorage.fileStat(at: WorkflowStorage.eventLogURL(for: dateKey))+ activeDateKey = dateKey+ activeFileOffset = stat?.size ?? 0+ activeFileIdentifier = stat?.identifier+ await onBatch(.bootstrapStart)+ await onBatch(.bootstrapEnd)+ }++ private func bootstrapAttempt(now: Date) async -> BootstrapResult? {+ let cutoff = now.addingTimeInterval(-Self.activityRetention)+ let dateKeys = Self.dateKeys(from: cutoff, through: now)+ let bootstrapDateKey = WorkflowStorage.dateKey(for: now)+ let boundaries = dateKeys.map { dateKey in+ let url = WorkflowStorage.eventLogURL(for: dateKey)+ let stat = WorkflowStorage.fileStat(at: url)+ return HookFileBoundary(+ dateKey: dateKey,+ url: url,+ size: stat?.size ?? 0,+ fileIdentifier: stat?.identifier+ )+ }++ await onBatch(.bootstrapStart)++ var activeCompleteOffset: UInt64 = 0+ for boundary in boundaries {+ guard isRunning, !Task.isCancelled else {+ return nil+ }++ let streamResult = await streamEvents(+ at: boundary.url,+ from: 0,+ through: boundary.size,+ cutoff: cutoff,+ makeBatch: HookEventBatch.bootstrapEvents+ )+ guard streamResult.didReachUpperBound else {+ return nil+ }+ if boundary.dateKey == bootstrapDateKey {+ activeCompleteOffset = streamResult.completeOffset+ }+ }++ guard boundariesAreStable(boundaries, activeDateKey: bootstrapDateKey),+ WorkflowStorage.dateKey(for: Date()) == bootstrapDateKey else {+ return nil+ }++ let activeBoundary = boundaries.first { $0.dateKey == bootstrapDateKey }+ return BootstrapResult(+ activeDateKey: bootstrapDateKey,+ activeFileOffset: activeCompleteOffset,+ activeFileIdentifier: activeBoundary?.fileIdentifier+ )+ }++ private func drainNewLines() async {+ guard isRunning, !Task.isCancelled else {+ return+ }++ let todayKey = WorkflowStorage.dateKey(for: Date())+ if todayKey != activeDateKey {+ // 跨零点先读完旧文件尾部,再切到新日期文件。+ guard await readAppendedLines() else {+ // bootstrap 已经完成切日;临时失败则保留旧日期,下一轮继续重试。+ return+ }+ activeDateKey = todayKey+ activeFileOffset = 0+ activeFileIdentifier = nil+ }++ _ = await readAppendedLines()+ }++ /// 返回是否读到当前文件上界;触发重新 bootstrap 或读取中断时为 false。+ private func readAppendedLines() async -> Bool {+ let url = activeFileURL+ let stat = WorkflowStorage.fileStat(at: url)+ if activeFileIdentifier != nil, stat?.identifier != activeFileIdentifier {+ await bootstrapRecentActivity()+ return false+ }+ if activeFileIdentifier == nil {+ activeFileIdentifier = stat?.identifier+ }++ let size = stat?.size ?? 0+ if size < activeFileOffset {+ await bootstrapRecentActivity()+ return false+ }++ guard size > activeFileOffset else {+ return true+ }++ let streamResult = await streamEvents(+ at: url,+ from: activeFileOffset,+ through: size,+ cutoff: nil,+ makeBatch: HookEventBatch.live+ )+ activeFileOffset = streamResult.completeOffset+ return streamResult.didReachUpperBound+ }++ /// 返回已处理完整行的绝对 offset 和是否读完固定上界;后续失败时保留此前进度。+ private func streamEvents(+ at url: URL,+ from startOffset: UInt64,+ through upperBound: UInt64,+ cutoff: Date?,+ makeBatch: ([WorkflowHookEvent]) -> HookEventBatch+ ) async -> HookEventStreamResult {+ guard upperBound > startOffset else {+ return .completed(at: startOffset)+ }+ guard let handle = try? FileHandle(forReadingFrom: url) else {+ return .interrupted(at: startOffset)+ }+ defer {+ try? handle.close()+ }++ guard (try? handle.seek(toOffset: startOffset)) != nil else {+ return .interrupted(at: startOffset)+ }++ var readOffset = startOffset+ var completeOffset = startOffset+ var pending = Data()++ while readOffset < upperBound {+ guard isRunning, !Task.isCancelled else {+ return .interrupted(at: completeOffset)+ }++ let requestedCount = Int(min(+ UInt64(Self.readChunkByteCount),+ upperBound - readOffset+ ))+ guard let chunk = try? handle.read(upToCount: requestedCount),+ !chunk.isEmpty else {+ return .interrupted(at: completeOffset)+ }++ readOffset += UInt64(chunk.count)+ pending.append(chunk)++ guard let lastNewlineIndex = pending.lastIndex(of: Self.newlineByte) else {+ await Task.yield()+ continue+ }++ let remainderStart = pending.index(after: lastNewlineIndex)+ let completeData = Data(pending[...lastNewlineIndex])+ pending = remainderStart < pending.endIndex+ ? Data(pending[remainderStart...])+ : Data()+ completeOffset = readOffset - UInt64(pending.count)++ var events = JSONLines.decode(WorkflowHookEvent.self, from: completeData)+ if let cutoff {+ events.removeAll { $0.timestamp < cutoff }+ }+ if !events.isEmpty {+ await onBatch(makeBatch(events))+ }+ await Task.yield()+ }++ return .completed(at: completeOffset)+ }++ /// 从 24 小时窗口之前的事件文件中定向查找 Prompt 起点,供 bootstrap 后回填恢复任务的开始时间。+ func findPromptStartTimes(+ for references: [CodexActivityPromptReference]+ ) -> [CodexActivityPromptReference: Date] {+ let cutoff = Date().addingTimeInterval(-Self.activityRetention)+ var unresolvedKeys = Set(references)+ var startTimes: [CodexActivityPromptReference: Date] = [:]+ var remainingBytes = Self.promptSearchByteLimit++ for url in eventLogURLs(onOrBefore: cutoff) {+ guard !unresolvedKeys.isEmpty, remainingBytes > 0 else {+ break+ }++ let size = WorkflowStorage.fileSize(at: url)+ let readCount = min(size, remainingBytes)+ guard readCount > 0,+ let handle = try? FileHandle(forReadingFrom: url) else {+ continue+ }+ defer {+ try? handle.close()+ }++ let readOffset = size - readCount+ guard (try? handle.seek(toOffset: readOffset)) != nil,+ let data = try? handle.read(upToCount: Int(readCount)),+ !data.isEmpty else {+ remainingBytes -= readCount+ continue+ }+ remainingBytes -= UInt64(data.count)++ var completeData = data+ if readOffset > 0, let firstNewlineIndex = data.firstIndex(of: Self.newlineByte) {+ let firstCompleteIndex = data.index(after: firstNewlineIndex)+ completeData = firstCompleteIndex < data.endIndex+ ? Data(data[firstCompleteIndex...])+ : Data()+ }++ for event in JSONLines.decode(WorkflowHookEvent.self, from: completeData)+ where event.hookEvent == .userPromptSubmit && event.timestamp < cutoff {+ guard let sessionId = event.sessionId, let turnId = event.turnId else {+ continue+ }+ let key = CodexActivityPromptReference(sessionId: sessionId, turnId: turnId)+ guard unresolvedKeys.remove(key) != nil else {+ continue+ }+ startTimes[key] = event.timestamp+ }+ }++ return startTimes+ }++ private func eventLogURLs(onOrBefore cutoff: Date) -> [URL] {+ let cutoffDateKey = WorkflowStorage.dateKey(for: cutoff)+ return WorkflowStorage.eventLogDateKeys()+ .filter { $0 <= cutoffDateKey }+ .sorted(by: >)+ .map { WorkflowStorage.eventLogURL(for: $0) }+ }++ private func boundariesAreStable(+ _ boundaries: [HookFileBoundary],+ activeDateKey: String+ ) -> Bool {+ for boundary in boundaries {+ let stat = WorkflowStorage.fileStat(at: boundary.url)+ guard stat?.identifier == boundary.fileIdentifier else {+ return false+ }+ let currentSize = stat?.size ?? 0+ if boundary.dateKey == activeDateKey {+ guard currentSize >= boundary.size else {+ return false+ }+ } else if currentSize != boundary.size {+ return false+ }+ }+ return true+ }++ private static func dateKeys(from start: Date, through end: Date) -> [String] {+ var calendar = Calendar(identifier: .gregorian)+ calendar.timeZone = .autoupdatingCurrent+ var date = calendar.startOfDay(for: start)+ let endDate = calendar.startOfDay(for: end)+ var keys: [String] = []++ while date <= endDate {+ keys.append(WorkflowStorage.dateKey(for: date))+ guard let nextDate = calendar.date(byAdding: .day, value: 1, to: date),+ nextDate > date else {+ break+ }+ date = nextDate+ }+ return keys+ }++ private static let pollInterval: TimeInterval = 2+ private static let activityRetention: TimeInterval = 24 * 60 * 60+ private static let readChunkByteCount = 512 * 1024+ private static let promptSearchByteLimit: UInt64 = 8 * 1024 * 1024+ private static let bootstrapAttemptLimit = 3+ private static let newlineByte: UInt8 = 0x0A+}++private nonisolated struct HookFileBoundary {+ let dateKey: String+ let url: URL+ let size: UInt64+ let fileIdentifier: UInt64?+}++private nonisolated struct BootstrapResult {+ let activeDateKey: String+ let activeFileOffset: UInt64+ let activeFileIdentifier: UInt64?+}++private nonisolated struct HookEventStreamResult {+ let completeOffset: UInt64+ let didReachUpperBound: Bool++ static func completed(at offset: UInt64) -> Self {+ Self(completeOffset: offset, didReachUpperBound: true)+ }++ static func interrupted(at offset: UInt64) -> Self {+ Self(completeOffset: offset, didReachUpperBound: false)+ }+}diff --git a/CodexBar/Services/Workflow/WorkflowService.swift b/CodexBar/Services/Workflow/WorkflowService.swiftindex 5f6d402..8a023de 100644--- a/CodexBar/Services/Workflow/WorkflowService.swift+++ b/CodexBar/Services/Workflow/WorkflowService.swift@@ -256,18 +256,7 @@ actor WorkflowService {}private func eventDateKeys() -> [String] {- guard let contents = try? FileManager.default.contentsOfDirectory(- at: eventsDirectoryURL,- includingPropertiesForKeys: nil- ) else {- return []- }-- return contents- .filter { $0.pathExtension == "jsonl" }- .map { $0.deletingPathExtension().lastPathComponent }- .filter { WorkflowStorage.isValidDateKey($0) }- .sorted()+ WorkflowStorage.eventLogDateKeys(in: eventsDirectoryURL)}private func buildDailyAggregate(@@ -650,6 +639,35 @@ nonisolated enum WorkflowStorage {return fileSize.uint64Value}+ /// 单次 stat 同时返回大小与 inode 标识, 文件缺失或不可读时为 nil+ static func fileStat(at url: URL) -> (size: UInt64, identifier: UInt64?)? {+ guard let attributes = try? FileManager.default.attributesOfItem(atPath: url.path) else {+ return nil+ }++ return (+ size: (attributes[.size] as? NSNumber)?.uint64Value ?? 0,+ identifier: (attributes[.systemFileNumber] as? NSNumber)?.uint64Value+ )+ }++ /// 枚举目录中文件名为合法日期键的 .jsonl 事件日志, 返回升序日期键+ static func eventLogDateKeys(in directoryURL: URL = eventsDirectoryURL()) -> [String] {+ guard let contents = try? FileManager.default.contentsOfDirectory(+ at: directoryURL,+ includingPropertiesForKeys: nil,+ options: [.skipsHiddenFiles]+ ) else {+ return []+ }++ return contents+ .filter { $0.pathExtension == "jsonl" }+ .map { $0.deletingPathExtension().lastPathComponent }+ .filter { isValidDateKey($0) }+ .sorted()+ }+static func retentionCutoffDate(today: Date = Date(), calendar: Calendar = .current) -> Date {cutoffDate(dayCount: retentionDayCount, today: today, calendar: calendar)}diff --git a/CodexBar/Views/Menu/CodexActivityCard.swift b/CodexBar/Views/Menu/CodexActivityCard.swiftnew file mode 100644index 0000000..f76820c--- /dev/null+++ b/CodexBar/Views/Menu/CodexActivityCard.swift@@ -0,0 +1,167 @@+import SwiftUI++/// Hook 开启时常驻的固定高度活动摘要,只在菜单面板可见时逐秒更新时间。+struct CodexActivityCard: View {+ let snapshot: CodexActivitySnapshot+ let isTimelineActive: Bool++ var body: some View {+ if isTimelineActive, needsPerSecondUpdates {+ TimelineView(.periodic(from: .now, by: 1)) { timeline in+ card(now: timeline.date)+ }+ } else {+ card(now: Date())+ }+ }++ /// 空闲文案不随时间变化,不需要逐秒重算。+ private var needsPerSecondUpdates: Bool {+ snapshot.primaryActivity != .idle+ }++ private func card(now: Date) -> some View {+ let content = content(at: now)+ return HStack(spacing: 10) {+ Image(systemName: content.symbolName)+ .font(.system(size: 14, weight: .semibold))+ .foregroundStyle(content.tint)+ .frame(width: 20)++ VStack(alignment: .leading, spacing: 3) {+ Text(content.title)+ .font(.caption.weight(.semibold))+ .lineLimit(1)+ .truncationMode(.middle)++ Text(content.detail)+ .font(.caption2)+ .foregroundStyle(.secondary)+ .lineLimit(1)+ .truncationMode(.tail)+ }++ Spacer(minLength: 0)++ if content.otherTaskCount > 0 {+ Text("+\(content.otherTaskCount)")+ .font(.caption2.monospacedDigit().weight(.semibold))+ .foregroundStyle(.secondary)+ .padding(.horizontal, 6)+ .padding(.vertical, 3)+ .background(.secondary.opacity(0.12), in: Capsule())+ .help("另有 \(content.otherTaskCount) 个任务")+ .accessibilityLabel("另有 \(content.otherTaskCount) 个任务")+ }+ }+ .padding(.horizontal, MenuMetrics.panelPadding)+ .frame(maxWidth: .infinity, minHeight: Metrics.height, maxHeight: Metrics.height)+ .liquidGlassSurface(cornerRadius: MenuMetrics.panelCornerRadius)+ }++ private func content(at now: Date) -> ActivityCardContent {+ switch snapshot.primaryActivity {+ case let .waiting(task):+ let details = [+ task.toolName ?? "等待下一步操作",+ "已等待 \(CodexActivityDurationFormat.text(for: now.timeIntervalSince(task.stateChangedAt)))"+ ]+ return ActivityCardContent(+ symbolName: "hand.raised.fill",+ tint: .orange,+ title: task.projectName ?? "Codex 等待批准",+ detail: details.joined(separator: " • "),+ otherTaskCount: otherTaskCount+ )+ case let .running(task):+ var titles = [task.projectName ?? "Codex"]+ if let modelName = task.modelName {+ titles.append(modelName)+ }++ var details: [String] = []+ if task.showsPreciseDuration, let startedAt = task.startedAt {+ details.append("已运行 \(CodexActivityDurationFormat.text(for: now.timeIntervalSince(startedAt)))")+ } else {+ details.append("正在运行")+ }+ details.append(Self.eventText(for: task))+ return ActivityCardContent(+ symbolName: "bolt.fill",+ tint: .blue,+ title: titles.joined(separator: " • "),+ detail: details.joined(separator: " • "),+ otherTaskCount: otherTaskCount+ )+ case let .completed(completion, _):+ var details: [String] = []+ if let duration = completion.duration {+ details.append("耗时 \(CodexActivityDurationFormat.text(for: duration))")+ }+ details.append(Self.completionRelativeText(completion.completedAt, now: now))+ return ActivityCardContent(+ symbolName: "checkmark.circle.fill",+ tint: .green,+ title: completion.projectName ?? "Codex 任务已完成",+ detail: details.joined(separator: " • "),+ otherTaskCount: 0+ )+ case .idle:+ return ActivityCardContent(+ symbolName: "waveform.path",+ tint: .secondary,+ title: "暂无 Codex 活动",+ detail: "Codex Hook 正在监测",+ otherTaskCount: 0+ )+ }+ }++ private var otherTaskCount: Int {+ max(0, snapshot.activeCount - 1)+ }++ private static func eventText(for task: CodexActivityTaskSnapshot) -> String {+ switch task.latestEvent {+ case .promptSubmitted:+ "正在思考"+ case .toolStarted:+ task.toolName.map { "调用工具 \($0)" } ?? "调用工具"+ case .toolFinished:+ task.toolName.map { "工具调用 \($0) 完成" } ?? "工具调用完成"+ case .compactionStarted:+ "压缩上下文"+ case .compactionFinished:+ "上下文压缩完成"+ case .subagentStarted:+ "启动子智能体"+ case .subagentFinished:+ "子智能体完成"+ case .approvalRequested:+ "等待批准"+ }+ }++ private static func completionRelativeText(_ completedAt: Date, now: Date) -> String {+ let seconds = max(0, Int(now.timeIntervalSince(completedAt)))+ if seconds < 10 {+ return "刚刚完成"+ }+ if seconds < 60 {+ return "\(seconds) 秒前完成"+ }+ return "\(seconds / 60) 分钟前完成"+ }++ private enum Metrics {+ static let height: CGFloat = 58+ }+}++private struct ActivityCardContent {+ let symbolName: String+ let tint: Color+ let title: String+ let detail: String+ let otherTaskCount: Int+}diff --git a/CodexBar/Views/Menu/CodexStatusMenuView.swift b/CodexBar/Views/Menu/CodexStatusMenuView.swiftindex 7e1d31f..9332bdd 100644--- a/CodexBar/Views/Menu/CodexStatusMenuView.swift+++ b/CodexBar/Views/Menu/CodexStatusMenuView.swift@@ -14,6 +14,7 @@ struct CodexStatusMenuView: View {@ObservedObject var viewModel: CodexStatusViewModel@ObservedObject var workflowViewModel: WorkflowViewModel@ObservedObject var codexHookSettings: CodexHookSettings+ @ObservedObject var activityMonitor: CodexActivityMonitor@ObservedObject var syncSettings: WorkflowSyncSettings@ObservedObject var menuSurfaceVisibility: MenuSurfaceVisibilityStatelet onUsageHeatmapHoverChange: (UsageHeatmapHoverContext?) -> Void@@ -55,6 +56,8 @@ private extension CodexStatusMenuView {onRefresh: viewModel.refresh)+ activityCard+dataSection(snapshot)} else {// 仅展示未登录 / 初始化失败两种特殊状态, 其余错误只进日志@@ -63,10 +66,21 @@ private extension CodexStatusMenuView {isRefreshing: viewModel.isRefreshing,onRefresh: viewModel.refresh)+ activityCardEmptyDataPanel()}}+ @ViewBuilder+ var activityCard: some View {+ if codexHookSettings.isEnabled {+ CodexActivityCard(+ snapshot: activityMonitor.snapshot,+ isTimelineActive: menuSurfaceVisibility.isVisible+ )+ }+ }+@ViewBuilderfunc dataSection(_ snapshot: CodexQuotaSnapshot) -> some View {if snapshot.limits.isEmpty, snapshot.usage == nil {diff --git a/Docs/CodexHook.md b/Docs/CodexHook.mdindex 4d31871..c90b1e2 100644--- a/Docs/CodexHook.md+++ b/Docs/CodexHook.md@@ -14,18 +14,18 @@ Codex 配置目录统一由 `CodexCLIResolver.codexHomeDirectory()` 解析: 优开启前会先复用 App 当前的 Codex app-server 会话调用 `config/read`。如果有效配置中 `[features] hooks = false`,或兼容旧名 `codex_hooks = false`,CodexBar 不写入 `hooks.json`,并在 Hook 选项下方显示全局禁用说明。-开启和关闭都会先移除 `command` 包含当前 App 可执行文件路径的 CodexBar hook。开启时随后按当前 App 路径安装 hook。用户自定义 Hook、其他 App Hook 和同事件下的其他处理器必须保留。+开启和关闭都会先移除 `command` 包含当前 App 可执行文件路径的 CodexBar Hook。开启时随后按当前 App 路径安装 Hook。用户自定义 Hook、其他 App Hook 和同事件下的其他 Hook 必须保留。-CodexBar 处理器的识别条件:+CodexBar Hook 的识别条件:- `type` 是 `command`- `command` 必须包含当前 App 可执行文件路径生成的 shell 命令和 `--hook-event` 参数, 例如 `'<当前 CodexBar 可执行文件路径>' --hook-event`-也就是说,如果用户手写的 Hook 命令同样包含当前 CodexBar 可执行文件路径和 `--hook-event` 参数,也会被当作当前 CodexBar 处理器移除;不同时包含当前路径和 `--hook-event` 的用户 Hook 会保留。+也就是说,如果用户手写的 Hook 命令同样包含当前 CodexBar 可执行文件路径和 `--hook-event` 参数,也会被当作当前 CodexBar Hook 移除;不同时包含当前路径和 `--hook-event` 的用户 Hook 会保留。-检测是否已开启时,只要任意 CodexBar 事件存在当前 App 路径对应的处理器,开关就保持开启;如果缺少部分事件,`hooks/list` 验证会在 Hook 选项下方显示 `CodexBar Hook 已不完整`。+检测是否已开启时,只要任意 CodexBar 事件存在当前 App 路径对应的 Hook,开关就保持开启;如果缺少部分事件,`hooks/list` 验证会在 Hook 选项下方显示 `CodexBar Hook 已不完整`。-关闭时会先通过 `hooks/list` 找出 `command` 属于当前 CodexBar 且来源为全局 `hooks.json` 的 Hook key;移除 `hooks.json` 中的处理器后,再通过 `config/read` + `config/batchWrite` 从 `hooks.state` 删除这些 key。清理失败不恢复已经关闭的 Hook,只在 Hook 选项下方提示清理信任状态失败。+关闭时会先通过 `hooks/list` 找出 `command` 属于当前 CodexBar 且来源为全局 `hooks.json` 的 Hook key;移除 `hooks.json` 中的 Hook 后,再通过 `config/read` + `config/batchWrite` 从 `hooks.state` 删除这些 key。清理失败不恢复已经关闭的 Hook,只在 Hook 选项下方提示清理信任状态失败。开启写入成功后会复用同一条 app-server 会话调用 `hooks/list` 做有效性检查:@@ -89,7 +89,7 @@ Hook stdin 会尝试解析为 Codex 官方 JSON 对象,只读取顶层字段事件名统计时会去掉 `_` 和 `-` 并转小写,因此 `PreToolUse`、`pre_tool_use`、`pre-tool-use` 会归为同一个事件。-常用项目名称只取目录最后一层,不过当前 popup 不展示该字段。+常用项目名称只取目录最后一层;实时活动卡片会展示该名称,完整路径不会进入 UI。## 本机存储@@ -101,7 +101,7 @@ Hook 数据目录:文件职责:-- `events/YYYY-MM-DD.jsonl`: 按本机日期拆分的原始 Hook 事件日志;开启「系统通知」的任务完成或任务等待提醒后,主 App 会以只读方式轮询 tail 当日 events 文件的新增行,用 `UserPromptSubmit` / `Stop` 判定长任务完成、用 `PermissionRequest` 判定等待批准;该读取不修改文件、不参与统计维护,统计口径不变。+- `events/YYYY-MM-DD.jsonl`: 按本机日期拆分的原始 Hook 事件日志;Hook 开启期间主 App 会以只读方式 tail 当日文件,为菜单栏、活动卡片和任务通知维护统一的进程内实时状态;该读取不修改文件、不参与统计维护,统计口径不变。- `daily.jsonl`: 每日聚合结果,UI 优先读取它- `stats.lock`: 并发写入锁文件,只用于 `flock`- `maintenance.json`: 记录待整理日期、需要重建日期和每个日期的处理进度@@ -129,6 +129,35 @@ Hook 数据目录:旧版单文件 `HookEvents/events.jsonl` 不参与新版统计、迁移或清理。+## 实时活动状态++`CodexActivityMonitor` 是 `@MainActor ObservableObject` 长期对象。Hook 开启时它启动 `HookEventTailReader`,关闭时停止读取并清空状态;通知总开关和任务通知子开关只控制是否发送通知,不控制监测器生命周期。实时状态只保存在内存,不写入新的历史文件,也不增加 CloudKit 字段或网络请求。++`HookEventTailReader` 是独立 actor,文件 I/O 和 JSON 解码不占用 MainActor。读取分为两类批次:++- `bootstrap`:App 启动、当前活动事件文件被截断或替换时,按 512 KB 分块流式读取滚动 24 小时涉及的日期文件,并按事件时间过滤窗口之外的数据。每次尝试开始时清空恢复态,成功后只发布一次最终快照,整个 bootstrap 不发布通知 transition。读取前记录各文件 inode 和 size;当前文件只读到当时最后一个完整换行,后续新增字节由 live 消费。文件边界变化时最多重试三次,连续失败则再次清空恢复态并跳过当前已有字节,避免把历史事件误当 live 通知。+- bootstrap 结束后,monitor 对由工具或权限事件恢复、但缺少起点的精确 session + turn,向 reader 发起一次定向查找:在更早日期文件中按 session + turn 查找 `UserPromptSubmit`,最多额外读取 8 MB;找到后只回填 `startedAt`,不改变当前状态、最近事件或活动时间。达到上限仍找不到时保留任务,但不展示精确总耗时。+- `live`:之后每 2 秒读取当天新增的完整行。末尾半行留到下次读取;跨零点时先读完旧文件尾部,再从新日期文件头开始。每个成功处理的分块都会推进到最后一个完整换行的 offset;后续分块读取失败时只重试尚未处理的部分。旧文件截断或替换触发 bootstrap 时,由 bootstrap 保留新日期的正确 offset,外层不会再从头按 live 重放;临时读取失败则保留旧日期并在下一轮重试。bootstrap、定时轮询和 Mac 唤醒补读共用串行入口;读取期间到达的请求只合并为一次待补读,并在当前读取结束后执行,避免 actor 在 `await` 处重入而重复消费同一 offset。monitor 为每一代 reader 分配 generation,快速开关 Hook 后迟到的旧批次会被丢弃。++Codex Hook 事件可能缺少起点、结束或中断信号。`CodexSessionLifecycleReader` 会补充读取本机 Codex session rollout:++- 只检查 monitor 内仍有运行或等待任务、并且同时具有 session ID 和 turn ID 的活跃项,不持续扫描所有历史会话。+- 优先在 `~/.codex/sessions/YYYY/MM/DD/` 和 `~/.codex/archived_sessions/` 按 session ID 定位对应 rollout;这些便宜目录允许每 10 秒重试。resume 的旧 session 找不到时,每个活跃生命周期只递归 `sessions` 一次并保留负缓存;session 重新活跃、缓存文件消失或 Mac 唤醒时重置递归资格。+- 初次从文件末尾最多读取 512 KB,之后每 2 秒按 byte offset 增量读取,保留半行并检测截断或替换。只解出顶层 `type`、`payload.type`、`payload.turn_id`、`started_at`、`completed_at` 和 `duration_ms`;不提取、保存或展示提示词、回复、推理或工具内容。+- `event_msg / task_started` 只为缺少 Hook Prompt 起点的精确 turn 回填开始时间;`task_complete` 补齐缺失的 Hook `Stop`,使用 `completed_at` 和 `duration_ms` 生成完成状态。初始恢复只更新状态而不回放通知;运行期间新收到的 `task_complete` 可发布一次完成 transition,后到的 Hook `Stop` 会被去重。定时轮询和唤醒/恢复触发的即时查询都绑定启动时的 reader generation,并在跨 actor 等待前后校验,旧 generation 的迟到 rollout 结果不会写入新状态。+- `event_msg / turn_aborted` 静默移除对应任务,不生成完成记录、绿色状态或通知。文件不存在、无法读取、格式变化或缺少精确 ID 时保留原 Hook 状态,最终仍由后续 prompt、Stop、Hook 关闭或 24 小时过期兜底。++任务状态机规则:++- 任务键优先使用 `session + turn`,缺少 turn 时使用 session;两者都缺少时按项目名归入匿名任务。匿名任务以及缺少起点的恢复任务不展示精确总耗时。+- `UserPromptSubmit` 创建运行任务;同一 session 收到新 prompt 时,旧 turn 即使缺少 Stop 也视为已中断并从运行状态移除,但不生成完成记录或通知。工具、上下文压缩和子智能体事件更新已有任务并解除等待,同时记录最近事件供活动卡片实时展示。工具和权限事件缺少起点时可以恢复顶层状态,子智能体事件不会单独创建顶层任务。+- `PermissionRequest` 进入等待批准;重复的等待事件不重复发布等待 transition。live 读取一次可能包含多个事件,monitor 会在整批应用后按任务键合并等待候选:最终仍在等待时使用最终快照发布一次,已经恢复运行、完成或移除时不发布过期等待 transition;完成候选保持事件顺序,并按 completion ID 防止同批重复发布。+- Hook `Stop` 或 rollout `task_complete` 结束任务并产生最近完成记录,两者在进程内按精确任务键和 session 回退键去重,保留第一次确认的完成及精确耗时且不重复发布 transition。后到的重复完成不会覆盖首次确认结果,也不会缩短 24 小时去重窗口。期间迟到的工具、压缩或权限事件不会恢复已完成任务,只有时间晚于完成记录的新 `UserPromptSubmit` 可以开始下一段生命周期。rollout `turn_aborted` 只静默移除中断任务。“完成”只表示该 turn 已结束,不表示任务成功。+- 精确 turn 匹配失败时,回退同 session 最近活动任务,再回退同项目匿名任务。+- UI 优先展示最近等待任务,其次最近运行任务,最后最近完成任务,同时保留运行与等待数量。运行卡片第一行组合项目与模型,第二行展示运行时间及最近的请求/工具/压缩/子智能体事件,其他任务数量以右侧 `+N` 徽标展示。菜单栏完成绿色保留 20 秒,最近完成卡片保留 5 分钟,24 小时没有新事件的活动自动过期。++跨日时仍在内存中的运行任务会继续保留;重启 App 后由滚动 24 小时 bootstrap 恢复近期活动,并为更早开始的精确 turn 定向回填起点。任务会一直保留到收到 Hook `Stop` 或 rollout `task_complete`、检测到 `turn_aborted`、同 session 新 prompt 将其淘汰、Hook 被关闭或连续 24 小时没有新事件。完成高亮、完成卡片、完成去重键和活动过期共用按最近到期时刻创建的单次清理任务,不运行常驻清理计时器;读取完成键时还会惰性淘汰已经超过 24 小时的记录,避免系统休眠或计时任务稍晚唤醒时误拦第一条新事件。+## 写入事务Hook 可能由多个 Codex 进程并发触发。`WorkflowHookEventRecorder` 会在同一个 `flock(LOCK_EX)` 中完成轻量写入事务:@@ -275,7 +304,7 @@ subagentStopCount, sessionCount, turnCount, projectCounts, modelCounts, sessionI| `sessionCount` | `sessionIds`、旧 `sessionCount`、`sessionStartCount` | 最近 3 天通常为 `null`;日期进入 3 天外窗口后,归一化时优先沿用已有 `sessionCount`,否则使用 `sessionIds.count`,再否则使用 `sessionStartCount`,然后移除 `sessionIds`。这样旧日期不用继续保存完整 ID,也能保留会话总数。 | 参与「会话总数」。 || `turnCount` | `turnIds`、旧 `turnCount`、`stopCount` | 最近 3 天通常为 `null`;日期进入 3 天外窗口后,归一化时优先沿用已有 `turnCount`,否则使用 `turnIds.count`,再否则使用 `stopCount`,然后移除 `turnIds`。这样旧日期不用继续保存完整 ID,也能保留轮次总数。 | 参与「对话轮次」。 || `projectCounts` | `cwd` | 任意事件行只要 `cwd` 非空,就取标准化路径的最后一层目录名作为项目名并 `+1`;如果最后一层为空,回退使用完整路径字符串。统计的是事件数,不是会话数或工具调用数。未知事件也会计入。 | 用于计算 `mostActiveProject`,当前页面不展示。 |-| `modelCounts` | `model` | 任意事件行只要 `model` 非空,就按原始模型名 `+1`。统计的是带模型字段的事件数,不是 token 数;未知事件也会计入。 | 合并后用于计算并展示「最热模型」。 |+| `modelCounts` | `model` | 任意事件行只要 `model` 非空,就按原始模型名 `+1`。统计的是带模型字段的事件数,不是 token 数;未知事件也会计入。 | 合并后用于计算并展示「最热模型」。 |读取旧 `daily.jsonl` 时,缺失的数字字段按 `0` 处理,缺失的 `projectCounts` / `modelCounts` 按空字典处理,缺失的 `sessionIds` / `turnIds` / `sessionCount` / `turnCount` 保持为 `nil`。维护 schema 升级到 `3` 后会把保留窗口内已有事件日期标记为 dirty,从原始事件重建模型计数;后续归一化仍按当前保留策略补齐或压缩 ID 字段。diff --git a/Docs/DevelopmentGuide.md b/Docs/DevelopmentGuide.mdindex 90ba791..5637755 100644--- a/Docs/DevelopmentGuide.md+++ b/Docs/DevelopmentGuide.md@@ -36,7 +36,7 @@ App 通过本机 Codex app-server 读取账号, 额度和 token 用量, 通过 C两条主数据链路:- Codex app-server 链路: `CodexStatusService` 启动或复用本机 app-server, 生成 `CodexQuotaSnapshot`, 由 `CodexStatusViewModel` 发布给菜单栏 UI-- Codex Hook 链路: Codex 进程触发带 `--hook-event` 参数的 Hook 命令, CodexBar 从 stdin payload 读取 `hook_event_name` 并快速写入 JSONL; 主 App 后续维护聚合并生成 `WorkflowSnapshot`+- Codex Hook 链路: Codex 进程触发带 `--hook-event` 参数的 Hook 命令, CodexBar 从 stdin payload 读取 `hook_event_name` 并快速写入 JSONL; 主 App 一路维护聚合并生成 `WorkflowSnapshot`, 另一路通过 `CodexActivityMonitor` 只读 tail 原始事件并发布实时活动快照;活跃 turn 再由 `CodexSessionLifecycleReader` 从本机 rollout 补充起点、结束和中断信号## 3. 启动流程@@ -66,14 +66,16 @@ sequenceDiagramend```-普通启动时, `CodexBarAppDelegate` 创建七个长期对象:+普通启动时, `CodexBarAppDelegate` 创建并持有这些长期对象:- `CodexStatusViewModel`: app-server 刷新状态- `WorkflowViewModel`: Hook 工作流统计快照- `CodexHookSettings`: Hook 配置状态和写入操作+- `CodexActivityMonitor`: Hook 实时任务状态、UI 快照和 live transition- `WorkflowSyncSettings`: 跨设备同步偏好、账号可用性、同步中和失败状态- `GlobalHotKeySettings`: 全局快捷键配置和错误状态- `MenuBarQuotaSettings`: 菜单栏额度指示偏好和窗口选择+- `NotificationSettings`: 本地通知偏好和系统授权状态- `AppUpdater`: Sparkle 更新状态`StatusItemController.install()` 负责:@@ -81,13 +83,14 @@ sequenceDiagram- 配置菜单栏按钮图标、可选额度进度条和点击事件- 配置菜单面板的 SwiftUI 根视图- 订阅状态变化并切换菜单栏图标+- 把统一活动快照注入菜单栏图标、tooltip 和菜单活动卡片- 订阅 Hook、同步开关和同步可用性变化, 把维护/同步请求交给 `WorkflowSyncScheduler`- 订阅全局快捷键配置并安装或移除 Carbon hot key- 开始每 60 秒自动刷新启动时还会把系统 tooltip 首次出现延迟 `NSInitialToolTipDelay` 设置为 200 ms, 让主面板同步图标等短提示更快出现。-App 退出时, `applicationWillTerminate` 调用 `StatusItemController.uninstall()`, 关闭菜单面板, 注销全局快捷键, 移除订阅并从系统状态栏移除 status item+App 退出时, `applicationWillTerminate` 调用 `StatusItemController.uninstall()` 和 `CodexActivityMonitor.stop()`, 关闭菜单面板与实时 tail, 注销全局快捷键, 移除订阅并从系统状态栏移除 status item## 4. 菜单栏, 菜单面板与窗口流程@@ -95,7 +98,11 @@ App 退出时, `applicationWillTerminate` 调用 `StatusItemController.uninstall正常图标是 `person.fill.checkmark`, 错误图标是 `person.fill.xmark`-设置页「菜单栏额度指示」默认开启, 使用独立开关控制启用状态; 缺失持久化选择时默认使用 `.primary`, 关闭时显式持久化 `.off`。开启后在同一行显示额度窗口菜单, 可选择当前账号 Codex limit 返回的额度窗口, 当前保留选择不在返回窗口中时用 fallback 标题追加到菜单。最后一次非关闭的窗口选择由 `MenuBarQuotaSettings` 以 `MenuBarQuota.lastWindowSelection` 键随偏好持久化: 关闭开关时它继续参与菜单淡出避免过渡期间回退, 重新开启时(含重开设置窗口或重启应用后)恢复该选择, 无记录时回退 `.primary`。关闭时菜单栏只使用系统 template 图标; 开启后 `StatusItemController` 会把所选 Codex 窗口的剩余额度进度条绘制在图标左侧, 以竖条形式与 `person.fill.checkmark` / `person.fill.xmark` 合成为单个 `NSImage`, 并随 `CodexStatusViewModel` 自动刷新。合成图尺寸为 `27 x 17`, 图标本体保持原始 `24 x 17`, 左侧竖条轨道为 `2 x 15`。开启或关闭进度条时, `StatusItemController` 用逐帧重绘的方式对左侧竖条透明度做 0.18 秒过渡; 过渡期间合成图宽度和图标绘制坐标保持固定。+小人颜色按 `账号异常 > 等待批准 > 运行中 > 刚完成 > 暂无活动` 取最高优先级:账号异常使用系统红色,等待批准使用系统橙色,运行中使用系统蓝色,确认 turn 完成后 20 秒内使用系统绿色,空闲使用 `labelColor`。空闲且没有额度竖条时保持 template 图像;彩色状态、账号异常或显示额度竖条时使用非 template 合成图。小人 tint 与额度竖条分别绘制,颜色互不影响。++设置页「菜单栏额度指示」默认开启, 使用独立开关控制启用状态; 缺失持久化选择时默认使用 `.primary`, 关闭时显式持久化 `.off`。开启后在同一行显示额度窗口菜单, 可选择当前账号 Codex limit 返回的额度窗口, 当前保留选择不在返回窗口中时用 fallback 标题追加到菜单。最后一次非关闭的窗口选择由 `MenuBarQuotaSettings` 以 `MenuBarQuota.lastWindowSelection` 键随偏好持久化: 关闭开关时它继续参与菜单淡出避免过渡期间回退, 重新开启时(含重开设置窗口或重启应用后)恢复该选择, 无记录时回退 `.primary`。开启后 `StatusItemController` 会把所选 Codex 窗口的剩余额度进度条绘制在图标左侧, 以竖条形式与 `person.fill.checkmark` / `person.fill.xmark` 合成为单个 `NSImage`, 并随 `CodexStatusViewModel` 自动刷新。合成图尺寸为 `27 x 17`, 图标本体保持原始 `24 x 17`, 左侧竖条轨道为 `2 x 15`。额度显隐或小人颜色变化时, `StatusItemController` 合并为同一个逐帧重绘任务,在 0.18 秒内同时插值竖条透明度和图标颜色,避免两个动画任务竞争;过渡期间合成图宽度和绘制坐标保持固定。活动期间 tooltip 每分钟更新一次耗时并合并并发数量与额度,活动结束后取消刷新任务。++Hook 开启时,账号卡片下方始终显示固定高度 `CodexActivityCard`;即使 app-server 异常进入空数据分支也不会隐藏。卡片按等待、运行、最近完成、空闲的顺序展示项目最后一级名称、模型或工具、耗时及其他任务数量。最近完成保留 5 分钟。耗时 `TimelineView` 只在 popover 或 fallback panel 可见时逐秒 tick。错误图标触发条件:@@ -582,9 +589,9 @@ flowchart TD详情面板分两种:-| Hook 状态 | 内容 | 尺寸 |-| --------- | ---------------------------------------------------------------------------------------------- | ----------- |-| 关闭 | 日期, token 数和"用量强度"分段条 | `212 x 84` |+| Hook 状态 | 内容 | 尺寸 |+| --------- | -------------------------------------------------------------------------------------------------------- | ----------- |+| 关闭 | 日期, token 数和"用量强度"分段条 | `212 x 84` || 开启 | 日期, token 数, "用量强度"分段条, 最热模型, 会话总数, 对话轮次, 子智能体, 工具调用, 权限请求, 上下文压缩 | `212 x 208` |Hook 开启且当天没有 token bucket 时, 今天的 token 数显示 `--`。日期使用 `AnimatedDateText` 做数字滚动, token 数使用 `TokenCountText` 并保留数字和单位宽度。@@ -644,9 +651,9 @@ sequenceDiagramConfig-->>Settings: 开关恢复实际状态并显示错误else 文件不存在或读取成功Config->>Config: 使用空配置或现有配置- Config->>Config: 移除 command 包含当前 App 路径的旧处理器- Config->>Config: 保留用户已有处理器和其他 App 处理器- Config->>Config: 为 10 个事件追加命令处理器+ Config->>Config: 移除 command 包含当前 App 路径的旧 Hook+ Config->>Config: 保留用户已有 Hook 和其他 App Hook+ Config->>Config: 为 10 个事件追加命令 HookConfig->>File: 原子写回配置alt 写入失败Config-->>Settings: 刷新实际状态并显示设置失败@@ -720,7 +727,7 @@ sequenceDiagram- `SubagentStart`- `SubagentStop`-每个处理器形如:+每个 Hook 形如:```bash'<当前 CodexBar 可执行文件路径>' --hook-event@@ -732,7 +739,7 @@ Hook 事件定义集中在 `CodexHookEvent`:- `appServerName`: 验证 `hooks/list` 使用, 例如 `sessionStart`- `init(eventName:)`: 统计 events 使用, 会把 `PreToolUse`, `pre_tool_use`, `pre-tool-use` 归一化到同一事件-识别和移除当前 CodexBar 处理器时必须同时满足:+识别和移除当前 CodexBar Hook 时必须同时满足:- handler 是 JSON 对象- `type == "command"`@@ -742,8 +749,8 @@ Hook 事件定义集中在 `CodexHookEvent`:- 用户已有 Hook 会被保留- 其他 App Hook 会被保留-- 同一事件下其他处理器会被保留-- 如果用户自定义 Hook 命令中也同时包含当前 CodexBar 可执行路径和 `--hook-event` 参数, 会被当作当前 CodexBar 处理器删除+- 同一事件下其他 Hook 会被保留+- 如果用户自定义 Hook 命令中也同时包含当前 CodexBar 可执行路径和 `--hook-event` 参数, 会被当作当前 CodexBar Hook 删除检测是否已开启时, 只要任意 CodexBar 事件存在当前 App 路径对应的 handler, 开关就保持开启。缺少部分事件时, `hooks/list` 验证会在 Hook 选项下方显示"CodexBar Hook 已不完整"。@@ -902,7 +909,7 @@ App 再次成为 active 时, 也会刷新 Codex 版本区、同步可用性, 并| 开机自动启动 | `SMAppService.mainApp.status` | `register()` / `unregister()` || 自动检查更新 | Sparkle updater | 设置 `automaticallyChecksForUpdates` || 菜单栏额度指示 | `MenuBarQuotaSettings.selection` / `MenuBarQuota.lastWindowSelection` | 开关写入 `.off` 或恢复持久化的上次窗口选择, 窗口菜单写入所选窗口并同步记住; 标签优先来自当前账号 Codex limit 返回的额度窗口, 缺失时使用 fallback 标题 |-| 系统通知 | `NotificationSettings` + `UNUserNotificationCenter` | 总开关与五类子开关、阈值写入 `UserDefaults`; 首次开启时请求系统通知授权 |+| 系统通知 | `NotificationSettings` + `UNUserNotificationCenter` | 总开关与五类子开关、阈值写入 `UserDefaults`; 首次开启时请求系统通知授权 || 使用快捷键 | `GlobalHotKeySettings.shortcut` | 写入 `UserDefaults` 并注册 hot key || 启用 Codex Hook | app-server `config/read` / `hooks/list` / `config/batchWrite`, `~/.codex/hooks.json` | 检查全局 Hook 开关后追加或移除当前 CodexBar command hook, 并维护对应 `hooks.state` 信任状态 || 跨设备同步 | `WorkflowSyncSettings` + CloudKit account status + `WorkflowSyncScheduler` | Hook 开启且同步账号可用时写入 `UserDefaults`; 开启时标记 `needsBackfill` 并请求调度同步 |@@ -1070,36 +1077,45 @@ App 再次成为 active 时, 也会刷新 Codex 版本区、同步可用性, 并- 不把原始敏感 RPC 响应写入文档或测试夹具- 日志完整保存 request/detail, UI 默认只渲染单行预览; 完整内容通过标题行预览或复制查看- Hook 统计默认只保存在用户 Application Support 的 CodexBar 目录;开启「跨设备同步」后, CloudKit 只保存去掉 `sessionIds` / `turnIds` 的 daily 聚合副本, 不保存原始 Hook events+- 实时任务状态只保存在 `CodexActivityMonitor` 内存中,UI 只展示项目最后一级名称、模型、工具名与最近 Hook 事件类型;运行卡片第一行组合项目和模型,第二行组合运行时间与请求/工具/压缩/子智能体状态,其他任务数使用右侧 `+N` 徽标。不写历史文件、不上传 CloudKit,也不新增网络请求。`CodexSessionLifecycleReader` 只对活跃 session + turn 增量读取本机 rollout,提取事件类型、turn ID、起止时间和耗时,不提取、保存或展示提示词、回复、推理和工具内容## 19. 通知提醒链路通知判定与发送在 `CodexBar/Services/Notifications/`, 偏好类随其他设置类放在 `CodexBar/Services/Settings/`:- `NotificationSettings` (`Services/Settings/`): 总开关、五类子开关、低额度阈值 (5%/10%/25%, 默认 10%) 和长任务时长 (30s/1m/2m/5m, 默认 1m), 持久化到 UserDefaults; 负责系统授权请求、被拒状态镜像和设置页选项面板可展示状态-- `CodexNotificationService`: 集中判定、去重、调度与发送; 由 `CodexBarAppDelegate` 创建, 订阅 `CodexStatusViewModel.$snapshot` 与 `NSWorkspace.didWakeNotification`; 五类正式通知共用 `CodexNotificationContent` 文案工厂-- `HookEventTailReader`: 2 秒轮询当日 `events/YYYY-MM-DD.jsonl` 大小, 只读增量解码新追加的完整行; 仅在总开关开启、系统授权未拒绝、Hook 启用, 且任务完成/任务等待任一子开关开启时运行+- `CodexNotificationService`: 集中判定、去重、调度与发送; 由 `CodexBarAppDelegate` 创建, 订阅 `CodexStatusViewModel.$snapshot`、`CodexActivityMonitor` live transition 与 `NSWorkspace.didWakeNotification`; 五类正式通知共用 `CodexNotificationContent` 文案工厂+- `CodexActivityMonitor`: Hook 开启期间始终运行并维护并发任务;向 UI 发布快照,向通知服务发布 live transition。单个 live 批次先完整应用事件,再按任务键合并等待候选;只有批次结束后仍处于等待的任务会使用最终快照发布一次等待 transition,完成候选保持顺序并按 completion ID 做批内去重。通知开关不会停止活动监测+- `HookEventTailReader` (`Services/Workflow/`): 后台 actor;bootstrap 以 512 KB 为单次分块流式读取滚动 24 小时事件,并用 start/events/end 三阶段恢复状态。当前文件用 inode + 完整行 offset 固定 bootstrap/live 边界;bootstrap 结束后 monitor 再发起一次定向回溯,为缺少起点的精确 turn 向旧日期文件最多回读 8 MB。之后每 2 秒 tail 当日增量,保留半行、跨日先读旧文件尾部;live 每成功处理一个分块就推进到最后完整行 offset,后续分块失败只重试未处理部分。旧文件异常触发 bootstrap 时保留 bootstrap 设置的新日期 offset,临时读取失败则保留旧日期等待下轮重试。bootstrap、定时轮询和 Mac 唤醒补读共用串行入口,读取期间到达的请求合并为当前读取结束后的一次补读;monitor generation 会丢弃停用 reader 的迟到批次+- `CodexSessionLifecycleReader`: 后台 actor,只为 monitor 当前的精确 session + turn 定位对应 rollout;便宜目录每 10 秒重试,每个活跃生命周期最多递归 `sessions` 一次并保留负缓存,缓存文件移动、session 重新活跃或 Mac 唤醒时重置。rollout 初次最多读取末尾 512 KB,之后按 offset 增量读取;`task_started` 回填缺失起点,`task_complete` 补齐结束和精确耗时,`turn_aborted` 由 monitor 静默移除任务,读取失败时不改变 Hook 状态。轮询和即时 lifecycle 查询都绑定 reader generation,跨 actor 返回后仍会复核,旧查询不能落入新 reader 状态++活动并发以 session 为边界:不同 session 可以同时运行;同一 session 的 turn 按顺序执行。收到新的 `UserPromptSubmit` 时,monitor 会移除该 session 中更早且缺少结束信号的 turn;rollout 收到 `turn_aborted` 时移除对应精确 turn。两种情况都视为中断而不是完成,因此不会触发绿色完成状态或长任务通知。Hook `Stop` 与 rollout `task_complete` 均视为完成信号,先到者生效,后到者按任务键和 session 回退键去重 24 小时;重复完成不会覆盖首次确认结果,也不会缩短去重窗口。去重键独立参与最近 deadline 清理,读取时也会惰性移除过期值;迟到的非 Prompt 事件不会重新恢复已完成任务,时间晚于完成记录的新 Prompt 才能开始下一段生命周期。设置页交互: 「系统通知」主开关行保留在设置窗口内, 子选项 (五类子开关与两个阈值 Picker) 在主选项右侧的子面板中展开 (`NotificationOptionsPanelController`, 复用 SidePanelSupport 抽屉机制挂在设置窗口上, 内容用常驻 hosting controller + ObservableObject 驱动, 面板尺寸在 Hook 开/关两种状态下保持不变)。「任务等待通知」紧跟在「任务完成通知」下方。主开关开启后仅在系统授权允许时展开, 首次授权场景会等待授权结果; 点击行内滑杆按钮可手动展开; 设置窗口 resign key/关闭、主开关关闭或授权变为被拒时自动收起。任务完成与任务等待子项在 Hook 未开启时显示为关闭并置灰, 不修改各自持久化偏好, Hook 重新开启后恢复用户原选择。授权被拒的引导文案与"打开系统设置"按钮仍内联显示在主开关行下方, 插入提示时不触发设置项纵向动画。五类通知的触发与去重:-| 通知 | 触发 | 去重键 |-| ------------ | -------------------------------------------------------------------------------- | ------------------------------------------ |-| 额度低阈值 | 非 stale 快照中窗口剩余比例穿越到 ≤ 阈值; 阈值或子开关变化时用当前快照立即重评估 | `low\|账号\|limitId\|windowId\|resetsAt` |-| 额度重置完成 | 本周期曾跌破阈值 (与低阈值子开关无关) 且到达 resetsAt; 补发时效为一个窗口周期 | `reset\|账号\|limitId\|windowId\|resetsAt` |-| 长任务完成 | Stop 事件按 session+turn (回退 session) 配对 UserPromptSubmit, 耗时 ≥ 阈值 | 每条 Stop 只配对一次 |-| 任务等待批准 | 实时读取到 `PermissionRequest` 事件 | 进程内按 timestamp+session+turn+tool 去重 |+| 通知 | 触发 | 去重键 |+| ------------ | -------------------------------------------------------------------------------------------------- | ------------------------------------------ |+| 额度低阈值 | 非 stale 快照中窗口剩余比例穿越到 ≤ 阈值; 阈值或子开关变化时用当前快照立即重评估 | `low\|账号\|limitId\|windowId\|resetsAt` |+| 额度重置完成 | 本周期曾跌破阈值 (与低阈值子开关无关) 且到达 resetsAt; 补发时效为一个窗口周期 | `reset\|账号\|limitId\|windowId\|resetsAt` |+| 长任务完成 | monitor 的 live Hook `Stop` 或 rollout `task_complete` transition 具有精确耗时且耗时 ≥ 阈值 | 状态机按精确任务键对两种完成信号去重 |+| 任务等待批准 | monitor 的 live 批次结束后任务最终仍处于 `waitingApproval` | 同批次按任务键合并,最终快照只发布一次 || 重置机会临期 | 过期时间距今 ≤ 7 天, 并在过期前 7/6/5/4/3/2/1 天各提醒一次; 正文使用本地时间 `yyyy-MM-dd HH:mm:ss` | `credit\|账号\|过期时间\|提醒档位` |-额度和重置机会通知的已发送去重键持久化在 UserDefaults (`Notification.sentKeys`, 上限 300 条滚动淘汰), 账号维度包含在键中, 切换账号自动隔离。任务等待去重只保留在当前进程内, tail 启动时从当日文件末尾开始, 不回放 App 启动前的历史权限事件。+额度和重置机会通知的已发送去重键持久化在 UserDefaults (`Notification.sentKeys`, 上限 300 条滚动淘汰), 账号维度包含在键中, 切换账号自动隔离。任务等待去重只保留在当前进程内。bootstrap 会恢复 App 启动前滚动 24 小时内的任务状态,但永远不发布 transition,因此不会补发历史权限或完成通知;重新开启通知也不会回放旧事件。通知错误处理 (延续"细节不打扰用户"原则, 不写入请求日志窗口):-| 场景 | 行为 |-| --------------------- | ------------------------------------------------ |-| 系统授权被拒 | 服务静默不发, 设置页显示引导与"打开系统设置"按钮 |-| 事件文件读取/解析失败 | 静默跳过本轮 tail, 其余通知不受影响 |-| 休眠错过 resetsAt | 唤醒时补检, 超过一个窗口周期的恢复提醒直接丢弃 |-| Hook 关闭或两个 Hook 通知子开关都关闭 | tail 停止并清空配对表 |+| 场景 | 行为 |+| ---------------------------- | --------------------------------------------------------------- |+| 系统授权被拒 | 服务静默不发, 设置页显示引导与"打开系统设置"按钮 |+| 当日事件文件临时读取失败 | 提交已处理完整行的 offset,下轮只重试剩余部分 |+| Hook 或 rollout 单行解码失败 | 跳过坏行并继续处理同批其他完整行,不写入请求日志 |+| 跨日旧文件临时读取失败 | 暂不切换日期,下一轮继续读取旧尾部;bootstrap 接管时不重放 live |+| rollout 文件不存在或读取失败 | 保留 Hook 推导的任务状态,不猜测任务已经中断 |+| 休眠错过 resetsAt | 唤醒时补检, 超过一个窗口周期的恢复提醒直接丢弃 |+| Hook 关闭 | monitor 停止 tail 并清空实时状态 |+| 通知总开关或任务通知关闭 | 仅阻止发送;monitor 与菜单栏活动状态继续更新 |通知点击通过 `UNUserNotificationCenterDelegate` 回调 `StatusItemController.openMenuSurfaceFromNotification()`, 复用全局快捷键的打开路径 (含 fallback 面板兜底)。diff --git a/README.md b/README.mdindex 19ad46d..0f48e76 100644--- a/README.md+++ b/README.md@@ -2,7 +2,7 @@> 常驻 macOS 菜单栏的 Codex 状态看板-CodexBar 在不打开 Codex CLI 或 Codex App 的情况下快速查看 Codex 账号状态、额度重置时间、Token 用量和本机使用情况统计。它连接本机 Codex app-server 获取账号与用量信息,也可以通过 Codex Hook 记录本机 Codex 事件,让菜单栏成为一个轻量、实时、的 Codex 仪表盘。+CodexBar 在不打开 Codex CLI 或 Codex App 的情况下快速查看 Codex 账号状态、额度重置时间、Token 用量和本机使用情况统计。它连接本机 Codex app-server 获取账号与用量信息,也可以通过 Codex Hook 记录本机 Codex 事件,让菜单栏成为一个轻量、实时的 Codex 仪表盘。<p align="center"><img src="Images/preview.gif" width="600">@@ -16,6 +16,7 @@ Codex 的额度、Token 用量和使用情况通常分散在终端、App 或 Ses- 跟踪不同时间窗口的额度剩余比例和下一次重置时间- 用 30 周热力图回顾每日 Token 用量- 在开启 Codex Hook 后在 30 周热力图中可查看当天最热模型,以及会话、对话轮次、工具调用、权限请求、上下文压缩和子智能体统计 (仅在开启后可记录查看,无法查看到历史数据)+- 通过菜单栏图标颜色和面板活动卡片实时查看 Codex 正在运行、等待批准及刚完成的任务- 通过可选 iCloud 私有数据库同步实现跨设备数据合并- 额度告急、额度恢复、任务等待批准、长任务完成时收到系统通知(可选开启)@@ -35,6 +36,10 @@ CodexBar 是一个无 Dock 图标的 macOS 菜单栏应用。「菜单栏额度指示」默认开启,菜单栏图标左侧会以一条细竖向进度条显示当前账号 Codex 额度中所选窗口的剩余比例;关闭后菜单栏图标保持纯图标显示。+开启 Codex Hook 后,菜单栏小人会用颜色反映实时任务状态:默认跟随系统颜色,运行中为蓝色、等待批准为橙色、刚完成为绿色,账号异常为红色。优先级依次为账号异常、等待批准、运行中、刚完成和暂无活动;额度竖条保持自己的颜色,不随小人状态改变。++菜单面板账号卡片下方会固定显示活动卡片,汇总当前项目、模型、工具、耗时和其他并发任务数量。绿色完成状态保留 20 秒,最近完成记录会在活动卡片保留 5 分钟;app-server 异常时活动卡片仍会继续展示本机 Hook 状态。+### 额度与重置时间一眼可见额度区用分段电量条展示不同时间窗口的剩余额度,并显示剩余百分比和重置时间。存在可用手动重置机会时,主 limit 标题右侧会显示 `重置次数: N`,点击后通过侧边详情面板按过期时间展示各重置机会的数量。@@ -53,7 +58,9 @@ CodexBar 是一个无 Dock 图标的 macOS 菜单栏应用。统计结果会汇总到热力图详情面板中,不打断正常的 Codex 使用流程。-CodexBar 只会追加或移除属于当前 CodexBar 可执行文件的 Hook 处理器,不会删除用户已有的其他 Codex Hook。+主 App 还会在后台只读 Hook JSONL:启动时按块恢复最近 24 小时的活动,之后 tail 当天新增事件,并在内存中维护并发任务状态。跨日任务缺少起点时会按精确 session + turn 定向查找更早的 Prompt;对于仍处于运行或等待状态的精确 turn,CodexBar 会增量读取对应本机 Codex session rollout,仅用 `task_started` 回填缺失起点、用 `task_complete` 补齐缺失的结束、用 `turn_aborted` 静默清理中断任务。不读取提示词、回复、推理或工具内容。该实时状态用于菜单栏颜色、活动卡片和可选任务通知,不新增历史状态文件,也不参与跨设备同步。++CodexBar 只会追加或移除属于当前 CodexBar 可执行文件的 Hook,不会删除用户已有的其他 Codex Hook。更详细的配置、存储和统计口径见 [Codex Hook 文档](Docs/CodexHook.md)@@ -79,6 +86,10 @@ CodexBar 会把该设备的使用详情数据同步到当前 iCloud 账号的 Cl五类通知可以单独开关;全部为本地通知,不新增网络请求。+Hook 事件可能在一次轮询中成批到达。CodexBar 会先处理完整批次,再按任务合并等待状态:只有批次结束后仍在等待批准的任务才通知一次;已经恢复运行、完成或移除的短暂等待不会产生过期提醒。++Hook `Stop` 与本机 rollout 的完成信号会统一去重;迟到的重复完成、工具或权限事件不会让已完成任务重复通知或重新显示为活动状态。+### 日志与版本信息CodexBar 内置请求日志窗口,用于查看 app-server 请求状态和排查刷新问题。设置页会展示 CodexBar 版本、当前 Codex CLI / Codex.app 版本、运行来源和本地安装路径,路径点击即可复制。@@ -119,6 +130,8 @@ Codex Hook 工作流数据默认只保存在本机:~/Library/Application Support/CodexBar/HookEvents/```+菜单栏实时任务状态只存在于当前 App 进程内。UI 只展示工作目录最后一级项目名,不展示完整路径;这份状态不会上传到 CloudKit,也不会产生新的网络请求。为补齐 Hook 缺失的起点、结束或中断信号,CodexBar 只对当前活跃 turn 增量读取 `~/.codex/sessions/` 或 `~/.codex/archived_sessions/` 下对应 rollout JSONL,解析生命周期事件、turn ID 和起止耗时;不会提取、保存或展示其中的提示词、回复、推理和工具内容。+只有在用户开启「跨设备同步」后,CodexBar 才会通过 `CloudKit private database` 同步每日使用详情数据; 同步的数据副本只包含各个事件数量、项目聚合和模型名使用次数,不包含事件具体的数据。除上述重置机会过期时间查询、Sparkle appcast / DMG 下载,以及用户开启跨设备同步后的 CloudKit 请求外,CodexBar 自身不发起其他网络请求。diff --git a/appcast.xml b/appcast.xmlindex 7d06aa9..ba0800c 100644--- a/appcast.xml+++ b/appcast.xml@@ -7,6 +7,15 @@<link>https://codexbar.zabrian.app/appcast.xml</link><description>CodexBar appcast feed</description><language>zh-CN</language>+ <item>+ <title>CodexBar.app 3.3.1</title>+ <sparkle:version>39</sparkle:version>+ <sparkle:shortVersionString>3.3.1</sparkle:shortVersionString>+ <sparkle:minimumSystemVersion>15.0</sparkle:minimumSystemVersion>+ <sparkle:releaseNotesLink>https://codexbar.zabrian.app/notes#3.3.1</sparkle:releaseNotesLink>+ <pubDate>Fri, 10 Jul 2026 16:30:18 +0800</pubDate>+ <enclosure url="https://codexbar.zabrian.app/download/CodexBar-v3.3.1.dmg" sparkle:edSignature="Qk0AW44MHcOn4t8XpDGcnLScEH3DxilCf86pUxLiFEY7V1tDZzlfN1ydQe0NHxRjuTln2ks1bMZIQo5Y6l2XAQ==" length="3859263" type="application/octet-stream"/>+ </item><item><title>CodexBar.app 3.3.0</title><sparkle:version>38</sparkle:version>