Skip to content

CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息

feat: 添加 Codex 实时任务状态

Bob43da06ae4d4e
diff --git a/AGENTS.md b/AGENTS.md
index 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 事件默认写入:
```text
diff --git a/CodexBar.xcodeproj/project.pbxproj b/CodexBar.xcodeproj/project.pbxproj
index 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.swift
index 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] in
controller?.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: CodexStatusViewModel
private let workflowViewModel: WorkflowViewModel
private let codexHookSettings: CodexHookSettings
+ private let activityMonitor: CodexActivityMonitor
private let syncSettings: WorkflowSyncSettings
private let globalHotKeySettings: GlobalHotKeySettings
private 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 = viewModel
self.workflowViewModel = workflowViewModel
self.codexHookSettings = codexHookSettings
+ self.activityMonitor = activityMonitor
self.syncSettings = syncSettings
self.globalHotKeySettings = globalHotKeySettings
self.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 == nil
let resolvedProgressVisibility = clampedProgressVisibility(progressVisibility)
let statusImage = NSImage(size: Metrics.progressStatusImageSize, flipped: false) { _ in
Self.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 == nil
statusImage.alignmentRect = Self.statusImageAlignmentRect(for: symbolImage)
return statusImage
}
@@ -279,13 +288,119 @@ private final class StatusItemController: NSObject, NSMenuDelegate {
private struct StatusIconState: Equatable {
let usesErrorImage: Bool
let progress: StatusIconProgress?
+ let activity: CodexActivitySnapshot
var 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 in
StatusIconState(
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] in
for 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) * easedProgress
statusItem.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.swift
new file mode 100644
index 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.swift
index 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: Date
let name: String
let directoryPath: String?
diff --git a/CodexBar/Services/Notifications/CodexNotificationService.swift b/CodexBar/Services/Notifications/CodexNotificationService.swift
index dd43cc5..2e81284 100644
--- a/CodexBar/Services/Notifications/CodexNotificationService.swift
+++ b/CodexBar/Services/Notifications/CodexNotificationService.swift
@@ -3,13 +3,12 @@ import Combine
import Foundation
import UserNotifications
-/// 集中式通知服务: 订阅额度快照, 负责阈值判定、去重、重置调度与本地通知发送
-/// 任务完成和等待批准通知的 Hook 事件接入见 handleHookEvents
+/// 集中式通知服务: 订阅额度与实时活动,负责阈值判定、去重、重置调度与本地通知发送。
@MainActor
final class CodexNotificationService: NSObject {
private let settings: NotificationSettings
private let statusViewModel: CodexStatusViewModel
- private let codexHookSettings: CodexHookSettings
+ private let activityMonitor: CodexActivityMonitor
private let defaults: UserDefaults
private nonisolated let openMenuSurface: @MainActor @Sendable () -> Void
@@ -25,23 +24,16 @@ final class CodexNotificationService: NSObject {
/// 阈值穿越判定的会话内上一帧剩余比例, key 为 account|limitId|windowId
private 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 = settings
self.statusViewModel = statusViewModel
- self.codexHookSettings = codexHookSettings
+ self.activityMonitor = activityMonitor
self.defaults = defaults
self.openMenuSurface = openMenuSurface
pendingResetReminders = 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 * 3600
private 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 * 3600
private static let sentKeysLimit = 300
private 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: - UNUserNotificationCenterDelegate
diff --git a/CodexBar/Services/Notifications/HookEventTailReader.swift b/CodexBar/Services/Notifications/HookEventTailReader.swift
deleted file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
index 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.swift
new file mode 100644
index 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.swift
index 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: MenuSurfaceVisibilityState
let 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
)
+ activityCard
EmptyDataPanel()
}
}
+ @ViewBuilder
+ var activityCard: some View {
+ if codexHookSettings.isEnabled {
+ CodexActivityCard(
+ snapshot: activityMonitor.snapshot,
+ isTimelineActive: menuSurfaceVisibility.isVisible
+ )
+ }
+ }
+
@ViewBuilder
func dataSection(_ snapshot: CodexQuotaSnapshot) -> some View {
if snapshot.limits.isEmpty, snapshot.usage == nil {
diff --git a/Docs/CodexHook.md b/Docs/CodexHook.md
index 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.md
index 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 @@ sequenceDiagram
end
```
-普通启动时, `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 @@ sequenceDiagram
Config-->>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 个事件追加命令 Hook
Config->>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.md
index 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.xml
index 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>