CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
import Foundation
import Testing
struct ActivityArchitectureTests {
@Test(arguments: [false, true])
func currentTurnSurvivesPreviousTurnsMillisecondProgress(snapshot: Bool) throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date(timeIntervalSince1970: floor(Date().timeIntervalSince1970) - 5)
monitor.consume(.live([TestFixtures.event(at: now.addingTimeInterval(-10))]))
monitor.consume(.live([TestFixtures.event(.toolCompleted, at: now.addingTimeInterval(0.1))]))
let event = TestFixtures.event(at: now, turn: "turn-b")
monitor.consume(snapshot ? .snapshotEvents([event]) : .live([event]))
let old = ActivityTaskKey(thread: "thread-a", turn: "turn-a")
let current = ActivityTaskKey(thread: "thread-a", turn: "turn-b")
let id = try #require(monitor.graph.tasks[current]?.displayID)
#expect(monitor.graph.tasks[old] == nil)
#expect(monitor.graph.pendingTerminalTasks[old] != nil)
monitor.consume(.snapshotEvents([event, TestFixtures.event(at: now)]))
#expect(monitor.graph.tasks[current]?.displayID == id)
#expect(monitor.graph.tasks.count == 1)
monitor.consume(.live([TestFixtures.event(.turnCompleted, at: now.addingTimeInterval(1))]))
#expect(monitor.graph.pendingTerminalTasks.isEmpty)
#expect(monitor.graph.completions.count == 1)
#expect(monitor.graph.terminations.isEmpty)
monitor.consume(.live([TestFixtures.event(.turnCompleted, at: now.addingTimeInterval(2), turn: "turn-b")]))
monitor.consume(.snapshotEvents([event]))
#expect(monitor.graph.tasks.isEmpty)
}
@Test func creationNoticeUpdatesRootWithoutInventingExecution() throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date()
monitor.consume(.snapshotEvents([TestFixtures.event(at: now)]))
var event = ActivityDataRecord(
timestamp: now.addingTimeInterval(1), name: ActivityDataEventKind.subagentStarted.rawValue, origin: .main,
cwd: "/child-project", toolName: nil, model: "child-model", effort: "low",
threadID: "thread-a", turnID: nil, agentThreadID: "child"
)
event.context = ActivityDataContext(
method: "item/completed", threadID: "thread-a", turnID: "turn-a",
rootThreadID: "thread-a", rootTurnID: "turn-a", agentThreadID: "child", itemKind: "started"
)
monitor.consume(.live([event]))
let task = try #require(monitor.graph.tasks[.init(thread: "thread-a", turn: "turn-a")])
#expect(task.modelName == "gpt-5")
#expect(task.projectName == "example")
#expect(task.effort == "mixed")
#expect(task.executions.keys.allSatisfy { $0.agentThreadID == nil })
#expect(task.subagentsByThreadID["child"]?.isRunning == true)
}
@Test func authoritativeChildrenRecoverCountWithoutObservedStarts() throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date()
monitor.consume(.snapshotEvents([TestFixtures.event(at: now)]))
let key = ActivityTaskKey(thread: "thread-a", turn: "turn-a")
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
let root = state("thread-a", at: now)
apply([root], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == 0)
monitor.graph.tasks[key]?.recordSubagentActivity(agentThreadID: "finished", isStarting: false, at: now)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
let finished = state("finished", at: now, parent: "thread-a", terminal: .completed(at: now, duration: 1))
let active = state("active", at: now, parent: "thread-a")
apply([root, finished, active], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == 1)
var unavailable = active
unavailable.readStatus = .unavailable
apply([root, finished, unavailable], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
apply([root, finished, active], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == 1)
apply([root, finished], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
let ended = state("active", at: now.addingTimeInterval(1), parent: "thread-a", terminal: .completed(at: now.addingTimeInterval(1), duration: 1))
apply([root, finished, ended], to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == 0)
}
@Test func unresolvedAncestryKeepsCountUnknownUntilOwnershipRecovers() throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date()
monitor.consume(.snapshotEvents([TestFixtures.event(at: now)]))
let root = ActivityTurnReference(threadID: "thread-a", turnID: "turn-a")
let child = ActivityTurnReference(threadID: "child", turnID: "turn-a")
let grandchild = ActivityTurnReference(threadID: "grandchild", turnID: "turn-a")
var states = [root: state("thread-a", at: now), child: state("child", at: now, parent: "thread-a"), grandchild: state("grandchild", at: now, parent: "child")]
for reference in [child, grandchild] {
states[reference]?.rootThreadID = nil
states[reference]?.rootTurnID = nil
}
let verified = Dictionary(uniqueKeysWithValues: states.keys.map { ($0, now) })
let incomplete = TurnLifecycleSnapshot(states: states, verifiedTurns: verified).lifecycleStates(for: [root], now: now)
#expect(incomplete.count == 3)
apply(incomplete, to: monitor)
let key = ActivityTaskKey(thread: "thread-a", turn: "turn-a")
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
for reference in [child, grandchild] {
states[reference]?.rootThreadID = "thread-a"
states[reference]?.rootTurnID = "turn-a"
}
let snapshot = TurnLifecycleSnapshot(states: states, verifiedTurns: verified)
apply(snapshot.lifecycleStates(for: [root], now: now), to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == 2)
let unidentified = TestFixtures.event(.toolStarted, at: now, origin: .auxiliary)
monitor.graph.tasks[key]?.recordExecutionEvent(unidentified)
apply(snapshot.lifecycleStates(for: [root], now: now), to: monitor)
#expect(monitor.graph.tasks[key]?.snapshot.activeSubagentCount == nil)
}
@Test func snapshotReconciliationIncludesEveryRetainedTaskWithoutDelay() throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date()
var transitions: [ActivityTransition] = []
var terminalStates: [ActivityTurnReference: TurnLifecycleState] = [:]
for index in 0 ..< 20 {
let event = TestFixtures.event(at: now, thread: "thread-\(index)")
let key = try #require(ActivityTaskKey(event: event))
let task = ActivityTask(displayID: UUID(), key: key, event: event, state: .running, startedAt: now, progressGeneration: 1)
monitor.resolveTerminal(.completed(at: now, duration: 1), task: task, key: key, abortFallback: now, into: &transitions)
let reference = task.turnReference
var lifecycle = state(reference.threadID, at: now, terminal: .completed(at: now, duration: 1))
lifecycle.rootThreadID = reference.threadID
terminalStates[reference] = lifecycle
let pendingEvent = TestFixtures.event(at: now, thread: "pending-\(index)")
let pendingKey = try #require(ActivityTaskKey(event: pendingEvent))
let pending = ActivityTask(displayID: UUID(), key: pendingKey, event: pendingEvent, state: .running, startedAt: now, progressGeneration: 1)
monitor.graph.pendingTerminalTasks[pendingKey] = PendingTerminalTask(task: pending, supersededAt: now)
}
let snapshot = TurnLifecycleSnapshot(states: terminalStates, verifiedTurns: [:])
let observedResult1 = monitor.graph.lifecycleReferences().count == 40
#expect(observedResult1)
monitor.graph.applyTerminalTokenUsage(snapshot.lifecycleStates(for: monitor.graph.lifecycleReferences()))
#expect(monitor.graph.completions.allSatisfy { $0.tokenUsage == nil })
for reference in terminalStates.keys {
terminalStates[reference]?.tokenUsage = TokenUsage(
inputTokens: 100, cachedInputTokens: 0, cacheWriteInputTokens: 0,
outputTokens: 0, reasoningOutputTokens: 0, totalTokens: 100
)
}
let updated = TurnLifecycleSnapshot(states: terminalStates, verifiedTurns: [:])
let observedResult3 = monitor.graph.lifecycleReferences().count == 40
#expect(observedResult3)
monitor.graph.applyTerminalTokenUsage(updated.lifecycleStates(for: monitor.graph.lifecycleReferences()))
#expect(monitor.graph.completions.count == 20)
#expect(monitor.graph.completions.allSatisfy { $0.tokenUsage?.totalTokens == 100 })
}
@Test(arguments: [false, true], [nil, "read", "search"] as [String?])
func approvalUsesRequestActionsWithoutInferringFromTool(cachedTool: Bool, action: String?) throws {
let now = Date()
var reducer = AppServerActivityReducer()
let thread = try mainThread()
_ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn", status: .running)], now: now)
if cachedTool {
let started = try TestFixtures.decode(ActivityInput.self, """
{"method":"item/started","params":{"threadId":"main","turnId":"turn",
"item":{"id":"item","type":"commandExecution","commandActions":[{"type":"read"}]}}}
""")
_ = reducer.consume(started, now: now)
}
let actions = action.map { "[{\"type\":\"\($0)\"}]" } ?? "null"
let request = try TestFixtures.decode(ActivityInput.self, """
{"id":1,"method":"item/commandExecution/requestApproval","params":{
"threadId":"main","turnId":"turn","itemId":"item","startedAtMs":1000,"commandActions":\(actions)}}
""")
let event = try #require(reducer.consume(request, now: now).first)
#expect(event.commandActionTypes == action.map { [$0] })
#expect(event.context?.itemType == "commandExecution")
#expect(reducer.states.values.first?.pendingApprovals.values.first?.commandActionTypes == action.map { [$0] })
let stored = try #require(AppServerEventRecord.decode(from: AppServerEventRecord(activityData: event).jsonLineData()).activityData)
#expect(stored.commandActionTypes == event.commandActionTypes)
}
@Test(arguments: [false, true])
func unknownStartRemainsUnknownUntilServerBackfill(snapshot: Bool) throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date(timeIntervalSince1970: floor(Date().timeIntervalSince1970))
var reducer = AppServerActivityReducer()
let thread = try mainThread()
let initial = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn", status: .running)], now: now)
if snapshot {
monitor.consume(.snapshotEvents(initial))
} else {
let started = try TestFixtures.decode(ActivityInput.self, """
{"method":"turn/started","params":{"threadId":"main","turn":{"id":"turn","status":"inProgress","startedAt":null}}}
""")
monitor.consume(.live(reducer.consume(started, now: now)))
}
let key = ActivityTaskKey(thread: "main", turn: "turn")
var task = try #require(monitor.graph.tasks[key])
let displayID = task.displayID
#expect(task.startedAt == nil)
#expect(task.preciseDuration(until: now) == nil)
let startedAt = now.addingTimeInterval(-60)
let corrected = ActivityTurn(id: "turn", status: .running, startedAt: startedAt)
_ = reducer.reconcile(thread: thread, turns: [corrected], now: now)
let state = try #require(reducer.states.values.first)
ActivityTaskGraph.mergeLifecycleBackfill(from: state, into: &task)
#expect(task.startedAt == startedAt)
#expect(task.preciseDuration(until: now) == 60)
#expect(task.displayID == displayID)
monitor.graph.tasks[key] = task
monitor.consume(.snapshotEvents(reducer.reconcile(
thread: thread, turns: [ActivityTurn(id: "turn", status: .running)], now: now, bootstrap: true
)))
#expect(monitor.graph.tasks[key]?.startedAt == startedAt)
}
@Test(arguments: ["completed", "failed", "interrupted"], [
(snapshot: false, timestamps: false), (snapshot: false, timestamps: true),
(snapshot: true, timestamps: false), (snapshot: true, timestamps: true)
])
func terminalUsesServerDurationForLiveAndSnapshot(status: String, scenario: (snapshot: Bool, timestamps: Bool)) throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let preferences = try TestPreferences()
defer { preferences.remove() }
let monitor = makeMonitor(directory, preferences)
defer { monitor.stop() }
let now = Date(timeIntervalSince1970: floor(Date().timeIntervalSince1970))
var reducer = AppServerActivityReducer()
let thread = try mainThread()
let key = ActivityTaskKey(thread: "main", turn: "turn")
let active = ActivityTurn(id: "turn", status: .running)
monitor.consume(.snapshotEvents(reducer.reconcile(thread: thread, turns: [active], now: now)))
let terminal = ActivityTurn(
id: "turn",
status: ActivityTurnStatus(rawValue: status) ?? .unknown,
startedAt: scenario.timestamps ? now.addingTimeInterval(-2) : nil,
completedAt: scenario.timestamps ? now : nil,
duration: 1.5
)
if scenario.snapshot {
_ = reducer.reconcile(thread: thread, turns: [terminal], now: now)
// 后续快照缺少时间字段时保留已经确认的终态时间和耗时
_ = reducer.reconcile(thread: thread, turns: [ActivityTurn(id: "turn", status: ActivityTurnStatus(rawValue: status) ?? .unknown)], now: now)
let lifecycle = try #require(reducer.states.values.first)
var task = try #require(monitor.graph.tasks[key])
ActivityTaskGraph.mergeLifecycleBackfill(from: lifecycle, into: &task)
var transitions: [ActivityTransition] = []
try monitor.resolveTerminal(#require(lifecycle.terminal), task: task, key: key, abortFallback: now, into: &transitions)
} else {
let start = terminal.startedAt.map { String($0.timeIntervalSince1970) } ?? "null"
let end = terminal.completedAt.map { String($0.timeIntervalSince1970) } ?? "null"
let completed = try TestFixtures.decode(ActivityInput.self, """
{"method":"turn/completed","params":{"threadId":"main","turn":{"id":"turn","status":"\(status)",
"startedAt":\(start),"completedAt":\(end),"durationMs":1500}}}
""")
monitor.consume(.live(reducer.consume(completed, now: now)))
}
if status == "completed" {
#expect(monitor.graph.completions.first?.duration == 1.5)
} else {
#expect(monitor.graph.terminations.first?.duration == 1.5)
#expect(monitor.graph.terminations.first?.isFailure == (status == "failed"))
}
}
private func mainThread() throws -> ActivityThread {
try TestFixtures.decode(ActivityThread.self, #"{"id":"main","source":"cli","status":{"type":"active"}}"#)
}
private func apply(_ states: [TurnLifecycleState], to monitor: ActivityMonitor) {
for state in states {
monitor.applySubagentLifecycle(state)
}
monitor.graph.reconcileSubagentCounts(states)
}
private func state(_ id: String, at date: Date, parent: String? = nil, terminal: TurnTerminalState? = nil) -> TurnLifecycleState {
TurnLifecycleState(
requestedThreadID: id, turnID: "turn-a", startedAt: date, effort: nil,
lastProgressAt: date, terminal: terminal, rootTurnID: "turn-a", rootThreadID: "thread-a", parentThreadID: parent
)
}
private func makeMonitor(_ directory: TestDirectory, _ preferences: TestPreferences) -> ActivityMonitor {
let monitor = ActivityMonitor(
protectionSettings: ProtectionSettings(defaults: preferences.defaults),
protectionStore: ProtectionStore(directoryURL: directory.url), activityDataDirectoryURL: directory.url
)
monitor.isActivitySourceHealthy = true
return monitor
}
}