CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
import Foundation
import Synchronization
import Testing
@Suite(.tags(.integration))
struct ActivityBackfillTests {
nonisolated enum BackfillOutcome: CaseIterable { case complete, stop, invalidResponse, liveCreation }
@Test(arguments: [false, true])
func shrinksSameCursorAndStopsAtOversizedItem(singleItemTooLarge: Bool) async throws {
let attempts = Mutex<[Int]>([])
let server = try SharedServerFixture(connections: singleItemTooLarge ? 5 : 4) { peer in
try Self.initialize(peer)
let request = try peer.readMessage()
let params = try #require(request["params"] as? [String: Any])
#expect(request["method"] as? String == "thread/items/list")
#expect(params["threadId"] as? String == "parent")
#expect(params["turnId"] as? String == "root")
#expect(params["sortDirection"] as? String == "desc")
#expect(params["cursor"] as? String == "same-cursor")
let limit = try #require(params["limit"] as? Int)
attempts.withLock { $0.append(limit) }
if limit > 2 || singleItemTooLarge {
try peer.sendHeader(length: 4097)
} else {
try peer.reply(to: request, result: ["data": [["turnId": "root", "item": ["id": "tool", "type": "commandExecution"]]], "nextCursor": "next-page"])
}
}
defer { server.close() }
let backfill = AppServerActivityBackfill(socketURL: server.url, logStorage: nil, maximumMessageSize: 4096)
do {
let page = try await backfill.readPage(reference: .init(threadID: "parent", turnID: "root"), cursor: "same-cursor", limit: 20, timeout: 3)
#expect(!singleItemTooLarge)
#expect(page.nextCursor == "next-page")
#expect(page.limit == 2)
#expect(page.items.first?.item.id == "tool")
} catch let error as CodexStatusError {
#expect(singleItemTooLarge)
guard case .messageTooLarge = error else { Issue.record("Wrong error: \(error)")
return
}
}
#expect(attempts.withLock { $0 } == (singleItemTooLarge ? [20, 10, 5, 2, 1] : [20, 10, 5, 2]))
try server.finish()
}
@Test func shrinkingRetriesShareOneDeadline() async throws {
let release = DispatchSemaphore(value: 0)
defer { release.signal() }
let requests = Mutex(0)
let server = try SharedServerFixture(connections: 2) { peer in
try Self.initialize(peer)
_ = try peer.readMessage()
let attempt = requests.withLock { $0 += 1
return $0
}
if attempt == 1 {
Thread.sleep(forTimeInterval: 0.15)
try peer.sendHeader(length: 4097)
} else {
_ = release.wait(timeout: .now() + 2)
}
}
defer { server.close() }
let backfill = AppServerActivityBackfill(socketURL: server.url, logStorage: nil, maximumMessageSize: 4096)
let started = Date()
do {
_ = try await backfill.readPage(reference: .init(threadID: "parent", turnID: "root"), cursor: nil, limit: 20, timeout: 0.3)
Issue.record("Expected shared deadline")
} catch let error as CodexStatusError {
guard case .serverTimeout = error else {
Issue.record("Wrong error: \(error)")
return
}
}
#expect(Date().timeIntervalSince(started) < 1)
#expect(requests.withLock { $0 } == 2)
release.signal()
try server.finish()
}
@Test(arguments: BackfillOutcome.allCases)
func slowItemResponseDoesNotBlockLiveCollectionOrDrain(outcome: BackfillOutcome) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let itemsStarted = DispatchSemaphore(value: 0)
let releaseItems = DispatchSemaphore(value: 0)
defer { itemsStarted.signal()
releaseItems.signal()
}
let timestamp = Date().addingTimeInterval(-60).timeIntervalSince1970
let server = try SharedServerFixture(connections: outcome == .stop ? 2 : 3, concurrentConnections: true) { peer in
try Self.serveLiveDuringBackfill(peer, itemsStarted: itemsStarted, releaseItems: releaseItems, timestamp: timestamp, outcome: outcome)
}
defer { server.close() }
let store = TokenUsageHistoryStore(directoryURL: directory.url)
let logs = AppServerLogStore(directoryURL: directory.url.appendingPathComponent("Logs"))
defer { await #expect(throws: Never.self) { try await logs.close() } }
let probe = ActivityReaderProbe()
var ready = false
var updates = 0
var unavailable = false
let reader = AppServerActivityReader(
probe: probe, socketURL: server.url, logStorage: logs, tokenUsageHistory: store, activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url)
) {
updates += 1
if $0.phase == .bootstrapEnd {
ready = true
}
if $0.phase == .sourceUnavailable {
unavailable = true
}
}
await reader.start()
let key = ActivityTaskKey(thread: "parent", turn: "root-turn")
for _ in 0 ..< 300 {
if ready, probe.graph.tasks[key]?.tokenUsage?.totalTokens == 50 {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(ready)
#expect(probe.graph.tasks[key]?.tokenUsage?.totalTokens == 50)
#expect(await reader.drainForRecovery(generation: UUID()).status == .completed)
#expect(!unavailable)
#expect(probe.graph.tasks[key]?.state == .running)
let progress = probe.graph.tasks[key]?.progressGeneration
let references = [ActivityTurnReference(threadID: "child", turnID: "child-turn")]
let before = await reader.lifecycleSnapshot.lifecycleStates(for: references).first
#expect(before?.effort == "high")
if outcome == .stop {
await reader.stop()
let stoppedUpdates = updates
releaseItems.signal()
try await Task.sleep(for: .milliseconds(200))
#expect(updates == stoppedUpdates)
} else {
let beforeBackfillUpdates = updates
releaseItems.signal()
if outcome == .invalidResponse {
try await Self.waitForBackfillFailure(logs)
} else {
for _ in 0 ..< 200 {
if updates > beforeBackfillUpdates {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(updates > beforeBackfillUpdates)
}
let after = await reader.lifecycleSnapshot.lifecycleStates(for: references).first
#expect(after?.effort == (outcome == .complete ? "mixed" : "high"))
#expect(after?.verifiedAt == before?.verifiedAt)
#expect(probe.graph.tasks[key]?.progressGeneration == progress)
#expect(probe.graph.tasks[key]?.state == .running)
#expect(probe.graph.tasks[key]?.tokenUsage?.totalTokens == 50)
#expect(await reader.drainForRecovery(generation: UUID()).status == .completed)
#expect(!unavailable)
try await Self.waitForItemReads(logs, count: 2)
await reader.stop()
}
#expect(try await store.refresh().first?.tokenUsage.totalTokens == 50)
try server.finish()
}
private static func waitForItemReads(_ logs: AppServerLogStore, count: Int) async throws {
for _ in 0 ..< 200 {
let successes = try await logs.page().entries.filter { $0.method == "thread/items/list" && $0.status == .success }.count
if successes >= count {
return
}
try await Task.sleep(for: .milliseconds(10))
}
Issue.record("Item pages did not finish")
}
private static func waitForBackfillFailure(_ logs: AppServerLogStore) async throws {
for _ in 0 ..< 200 {
if try await logs.page().entries.contains(where: { $0.method == "activity/backfill" && $0.status == .failure }) {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(try await logs.page().entries.contains { $0.method == "activity/backfill" && $0.status == .failure })
}
private nonisolated static func serveLiveDuringBackfill(
_ peer: SharedServerFixture.Peer, itemsStarted: DispatchSemaphore, releaseItems: DispatchSemaphore, timestamp: Double, outcome: BackfillOutcome
) throws {
let name = try Self.initialize(peer)
if name == "codex_bar_activity_backfill" {
let request = try peer.readMessage()
let params = try #require(request["params"] as? [String: Any])
#expect(request["method"] as? String == "thread/items/list")
if params["threadId"] as? String == "child" {
try peer.reply(to: request, result: ["data": []])
return
}
var body = try JSONSerialization.data(withJSONObject: ["id": #require(request["id"]), "result": ["data": [[
"turnId": "root-turn", "startedAtMs": timestamp * 1000, "completedAtMs": (timestamp + 1) * 1000,
"item": [
"id": "spawn",
"type": "subAgentActivity",
"kind": "started",
"agentThreadId": "child",
"reasoningEffort": "low",
"ignoredOutput": String(repeating: "a", count: 200000)
]
]]]])
if outcome == .invalidResponse {
body = try JSONSerialization.data(withJSONObject: ["id": #require(request["id"]), "result": ["data": "invalid", "padding": String(repeating: "a", count: 200000)]])
}
try peer.sendHeader(length: UInt64(body.count))
try peer.sendBytes(body.prefix(100))
itemsStarted.signal()
#expect(releaseItems.wait(timeout: .now() + 5) == .success)
if outcome == .stop {
try? peer.sendBytes(body.dropFirst(100))
} else {
try peer.sendBytes(body.dropFirst(100))
}
return
}
var sent = false
while let request = try? peer.readMessage() {
let params = request["params"] as? [String: Any] ?? [:]
let id = params["threadId"] as? String ?? ""
switch request["method"] as? String {
case "thread/loaded/list":
try peer.reply(to: request, result: ["data": ["parent", "child"]])
case "thread/read", "thread/resume":
var thread: [String: Any] = ["id": id, "source": "cli", "status": ["type": "active"], "reasoningEffort": "high"]
if id == "child" {
thread["parentThreadId"] = "parent"
}
try peer.reply(to: request, result: ["thread": thread])
case "thread/turns/list":
#expect(params["itemsView"] as? String == "notLoaded")
try peer.reply(to: request, result: ["data": [[
"id": id == "parent" ? "root-turn" : "child-turn", "rootTurnId": "root-turn", "status": "inProgress", "startedAt": timestamp
]]])
if id == "parent", !sent {
sent = true
#expect(itemsStarted.wait(timeout: .now() + 3) == .success)
try Self.sendLiveUpdates(peer, timestamp: timestamp)
if outcome == .liveCreation {
try peer.send(["method": "item/completed", "params": ["threadId": "parent", "turnId": "root-turn", "item": [
"id": "live-spawn", "type": "subAgentActivity", "kind": "started", "agentThreadId": "child", "reasoningEffort": "high"
]]])
}
}
default: Issue.record("Unexpected request")
}
}
}
@discardableResult
private nonisolated static func initialize(_ peer: SharedServerFixture.Peer) throws -> String? {
let request = try peer.readMessage()
#expect(request["method"] as? String == "initialize")
let client = (request["params"] as? [String: Any])?["clientInfo"] as? [String: Any]
try peer.reply(to: request, result: ["userAgent": "codex/0.162.0"])
#expect(try peer.readMessage()["method"] as? String == "initialized")
return client?["name"] as? String
}
private nonisolated static func sendLiveUpdates(_ peer: SharedServerFixture.Peer, timestamp: Double) throws {
for index in 0 ..< 30 {
try peer.send(["method": "item/started", "params": [
"threadId": "parent", "turnId": "root-turn", "item": ["id": "tool-\(index)", "type": "commandExecution"]
]])
}
try peer.send(["id": "approval", "method": "item/commandExecution/requestApproval", "params": [
"threadId": "parent", "turnId": "root-turn", "itemId": "approval-tool", "startedAtMs": (timestamp + 10) * 1000
]])
try peer.send(["method": "serverRequest/resolved", "params": ["threadId": "parent", "requestId": "approval"]])
try peer.send(["method": "thread/status/changed", "params": ["threadId": "parent", "status": ["type": "active", "activeFlags": []]]])
for total in [100, 120, 150] {
let usage = ["inputTokens": total, "cachedInputTokens": 0, "outputTokens": 0, "reasoningOutputTokens": 0, "totalTokens": total]
try peer.send(["method": "thread/tokenUsage/updated", "params": [
"threadId": "parent", "turnId": "root-turn", "tokenUsage": ["total": usage, "last": usage]
]])
}
}
}
extension ActivityBackfillTests {
@Test func newSubagentDoesNotRestartCurrentHistoryScan() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let firstPage = DispatchSemaphore(value: 0)
let releasePage = DispatchSemaphore(value: 0)
defer { firstPage.signal()
releasePage.signal()
}
let cursors = Mutex<[String?]>([])
let queriedThreads = Mutex<Set<String>>([])
let completedChild = Mutex(false)
let childReads = Mutex(0)
let timestamp = Date().addingTimeInterval(-60).timeIntervalSince1970
let server = try SharedServerFixture(connections: 4, concurrentConnections: true) { peer in
if try Self.initialize(peer) == "codex_bar_activity_backfill" {
let request = try peer.readMessage()
let params = try #require(request["params"] as? [String: Any])
let threadID = try #require(params["threadId"] as? String)
_ = queriedThreads.withLock { $0.insert(threadID) }
if params["threadId"] as? String == "child" {
try peer.reply(to: request, result: ["data": []])
return
}
let cursor = params["cursor"] as? String
let index = cursors.withLock { $0.append(cursor)
return $0.count
}
if index == 1 {
firstPage.signal()
#expect(releasePage.wait(timeout: .now() + 3) == .success)
try peer.reply(to: request, result: ["data": [], "nextCursor": "older"])
} else {
let items = ["child", "new-child"].map { child in
["turnId": "root", "item": [
"id": "spawn-" + child,
"type": "subAgentActivity",
"kind": "started",
"agentThreadId": child,
"reasoningEffort": "low"
]] as [String: Any]
}
try peer.reply(to: request, result: ["data": items])
}
} else {
try Self.serveNewSubagent(peer, timestamp: timestamp, firstPage: firstPage, completedChild: completedChild, childReads: childReads)
}
}
defer { server.close() }
let reader = AppServerActivityReader(
socketURL: server.url, logStorage: nil, tokenUsageHistory: TokenUsageHistoryStore(directoryURL: directory.url),
activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url), onBatch: { _ in }
)
await reader.start()
let references = [ActivityTurnReference(threadID: "new-child", turnID: "new-child-turn"), .init(threadID: "child", turnID: "child-turn")]
for _ in 0 ..< 200 {
if await reader.lifecycleSnapshot.lifecycleStates(for: references).contains(where: { $0.requestedThreadID == "new-child" && $0.startedAt != nil }) {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(await reader.lifecycleSnapshot.lifecycleStates(for: references).contains { $0.requestedThreadID == "new-child" && $0.startedAt != nil })
releasePage.signal()
for _ in 0 ..< 200 {
if await reader.lifecycleSnapshot.lifecycleStates(for: references).allSatisfy({ $0.effort == "low" }) {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(await reader.lifecycleSnapshot.lifecycleStates(for: references).allSatisfy { $0.effort == "low" })
#expect(cursors.withLock { $0 } == [nil, "older"])
completedChild.withLock { $0 = true }
_ = await reader.drainForRecovery(generation: UUID())
let readsAfterCompletion = childReads.withLock { $0 }
_ = await reader.drainForRecovery(generation: UUID())
#expect(childReads.withLock { $0 } == readsAfterCompletion)
await reader.stop()
try server.finish()
#expect(queriedThreads.withLock { $0 } == ["parent", "child"])
}
private nonisolated static func serveNewSubagent(
_ peer: SharedServerFixture.Peer, timestamp: Double, firstPage: DispatchSemaphore,
completedChild: borrowing Mutex<Bool>, childReads: borrowing Mutex<Int>
) throws {
var sent = false
while let request = try? peer.readMessage() {
let id = (request["params"] as? [String: Any])?["threadId"] as? String ?? ""
switch request["method"] as? String {
case "thread/loaded/list": try peer.reply(to: request, result: ["data": completedChild.withLock { $0 } ? ["parent"] : ["parent", "child"]])
case "thread/read", "thread/resume":
var thread: [String: Any] = ["id": id, "source": "cli", "status": ["type": "active"]]
if id == "child" {
childReads.withLock { $0 += 1 }
if completedChild.withLock({ $0 }) {
thread["status"] = ["type": "notLoaded"]
}
}
if id != "parent" {
thread["parentThreadId"] = "parent"
}
try peer.reply(to: request, result: ["thread": thread])
case "thread/turns/list":
var turn: [String: Any] = [
"id": id == "parent" ? "root" : id + "-turn", "rootTurnId": "root", "status": "inProgress", "startedAt": timestamp
]
if id == "child", completedChild.withLock({ $0 }) {
turn["status"] = "completed"
turn["completedAt"] = timestamp + 30
}
try peer.reply(to: request, result: ["data": [turn]])
if id == "parent", !sent {
sent = true
#expect(firstPage.wait(timeout: .now() + 3) == .success)
try peer.send(["method": "thread/started", "params": ["thread": [
"id": "new-child", "parentThreadId": "parent", "source": "cli", "status": ["type": "active"]
]]])
try peer.send(["method": "turn/started", "params": ["threadId": "new-child", "turn": [
"id": "new-child-turn", "rootTurnId": "root", "status": "inProgress", "startedAt": Date().timeIntervalSince1970
]]])
}
default: Issue.record("Unexpected request")
}
}
}
}
extension ActivityBackfillTests {
@Test(arguments: [false, true])
func historyAndLiveActivityShareIdentityWithoutReplayingState(historyFirst: Bool) async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let now = Date()
let reference = ActivityTurnReference(threadID: "main", turnID: "root")
var reducer = AppServerActivityReducer()
_ = reducer.reconcile(
thread: .init(id: "main", status: .init(type: .active), origin: .main),
turns: [.init(id: "root", status: .running, rootTurnId: "root", startedAt: now.addingTimeInterval(-60))],
now: now
)
let started = try TestFixtures.decode(ActivityInput.self, """
{"method":"item/started","params":{"threadId":"main","turnId":"root","item":{"id":"tool","type":"commandExecution","commandActions":[
{"type":"search"},{"type":"read"},{"type":"read"}]}}}
""")
let live = reducer.consume(started, now: now)
let before = try #require(reducer.states[reference])
let entry = ActivityItemEntry(
turnId: "root",
item: ActivityItem(
id: "tool",
type: .commandExecution,
status: "completed",
commandActions: [.init(type: "search"), .init(type: "read"), .init(type: "read")]
),
startedAtMs: now.addingTimeInterval(-30).timeIntervalSince1970 * 1000,
completedAtMs: now.addingTimeInterval(-20).timeIntervalSince1970 * 1000
)
let history = reducer.historicalEvents([entry], reference: reference, now: now.addingTimeInterval(10))
#expect(history.first?.id == live.first?.id)
#expect(reducer.states[reference]?.lastProgressAt == before.lastProgressAt)
#expect(reducer.states[reference]?.isWaitingApproval == before.isWaitingApproval)
#expect(reducer.states[reference]?.terminal == nil)
let recorder = ActivityDataRecorder(directoryURL: directory.url)
try await recorder.record(events: historyFirst ? history : live)
try await recorder.record(events: historyFirst ? live : history)
try await ActivityDataRecorder(directoryURL: directory.url).record(events: history)
let database = try HistoryDatabase(directoryURL: directory.url)
let aggregate = try database.aggregateActivityData(date: HistoryStorage.dateKey(for: now))
#expect(aggregate.toolStartedCount == 3)
#expect(aggregate.toolCompletedCount == 3)
#expect(aggregate.eventCount == 2)
#expect(aggregate.approvalRequestedCount == 0)
}
@Test func consecutiveReaderRestartsDeduplicateActivityAndContinueTokenBaseline() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let start = Date().addingTimeInterval(-3600)
let initial = TokenUsageHistoryStore(directoryURL: directory.url)
_ = try await initial.record(TestFixtures.tokenSample(100, at: start, start: start))
_ = try await initial.record(TestFixtures.tokenSample(150, at: start, start: start))
for (count, total) in [(2, 200), (3, 300)] {
let server = try SharedServerFixture(connections: 2, concurrentConnections: true) { peer in
let client = try Self.initialize(peer)
if client == "codex_bar_activity_backfill" {
let request = try peer.readMessage()
#expect(request["method"] as? String == "thread/items/list")
let entries = (1 ... count).map { index in
[
"turnId": "root",
"startedAtMs": start.timeIntervalSince1970 * 1000,
"item": ["id": "tool-\(index)", "type": "commandExecution", "status": "inProgress"]
] as [String: Any]
}
try peer.reply(to: request, result: ["data": entries])
return
}
var emitted = false
while let request = try? peer.readMessage() {
switch request["method"] as? String {
case "thread/loaded/list": try peer.reply(to: request, result: ["data": ["main"]])
case "thread/read", "thread/resume":
try peer.reply(to: request, result: ["thread": ["id": "main", "source": "cli", "status": ["type": "active"]]])
case "thread/turns/list":
#expect((request["params"] as? [String: Any])?["itemsView"] as? String == "notLoaded")
try peer.reply(to: request, result: ["data": [["id": "root", "rootTurnId": "root", "status": "inProgress", "startedAt": start.timeIntervalSince1970]]])
if !emitted {
emitted = true
let usage = ["inputTokens": total, "cachedInputTokens": 0, "outputTokens": 0, "reasoningOutputTokens": 0, "totalTokens": total]
try peer.send(["method": "thread/tokenUsage/updated", "params": ["threadId": "main", "turnId": "root", "tokenUsage": ["total": usage, "last": usage]]])
try peer.send(["method": "item/started", "params": ["threadId": "main", "turnId": "root", "item": ["id": "tool-\(count)", "type": "commandExecution"]]])
}
default: Issue.record("Unexpected request")
}
}
}
defer { server.close() }
let probe = ActivityReaderProbe()
let store = TokenUsageHistoryStore(directoryURL: directory.url)
let reader = AppServerActivityReader(
probe: probe,
socketURL: server.url,
logStorage: nil,
tokenUsageHistory: store,
activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url),
onBatch: { _ in }
)
await reader.start()
for _ in 0 ..< 300 {
let tools = try directory.historyRecords().filter { $0.activityData?.eventKind == .toolStarted }.count
if tools == count, probe.graph.tasks[.init(thread: "main", turn: "root")]?.tokenUsage?.totalTokens == Int64(total - 100) {
break
}
try await Task.sleep(for: .milliseconds(10))
}
#expect(probe.graph.tasks[.init(thread: "main", turn: "root")]?.tokenUsage?.totalTokens == Int64(total - 100))
#expect(await reader.stop())
let database = try HistoryDatabase(directoryURL: directory.url)
let aggregate = try database.aggregateActivityData(date: HistoryStorage.dateKey(for: start))
#expect(aggregate.toolStartedCount == count)
#expect(aggregate.turnStartedCount == 1)
#expect(try await store.refresh().first?.tokenUsage.totalTokens == Int64(total - 100))
try server.finish()
}
}
}
extension ActivityBackfillTests {
@Test func taskStartedWhileReaderIsConnectedDoesNotQueryHistory() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let logs = AppServerLogStore(directoryURL: directory.url.appendingPathComponent("Logs"))
defer { await #expect(throws: Never.self) { try await logs.close() } }
let startTask = Mutex(false)
let server = try SharedServerFixture { peer in
try Self.initialize(peer)
var startedAt: Double?
while let request = try? peer.readMessage() {
switch request["method"] as? String {
case "thread/loaded/list":
if startTask.withLock({ $0 }), startedAt == nil {
let timestamp = Date().timeIntervalSince1970
startedAt = timestamp
try peer.send(["method": "thread/started", "params": ["thread": ["id": "main", "source": "cli", "status": ["type": "active"]]]])
try peer.send(["method": "turn/started", "params": ["threadId": "main", "turn": [
"id": "root", "rootTurnId": "root", "status": "inProgress", "startedAt": timestamp
]]])
}
try peer.reply(to: request, result: ["data": startedAt == nil ? [] : ["main"]])
case "thread/read", "thread/resume":
try peer.reply(to: request, result: ["thread": ["id": "main", "source": "cli", "status": ["type": "active"]]])
case "thread/turns/list":
#expect((request["params"] as? [String: Any])?["itemsView"] as? String == "notLoaded")
try peer.reply(to: request, result: ["data": [[
"id": "root", "rootTurnId": "root", "status": "inProgress", "startedAt": #require(startedAt)
]]])
default: Issue.record("Unexpected request")
}
}
}
defer { server.close() }
var ready = false
let probe = ActivityReaderProbe()
let reader = AppServerActivityReader(
probe: probe,
socketURL: server.url,
logStorage: logs,
tokenUsageHistory: TokenUsageHistoryStore(directoryURL: directory.url),
activityDataRecorder: ActivityDataRecorder(directoryURL: directory.url)
) {
if $0.phase == .bootstrapEnd {
ready = true
}
}
await reader.start()
for _ in 0 ..< 200 where !ready {
try await Task.sleep(for: .milliseconds(5))
}
#expect(ready)
startTask.withLock { $0 = true }
#expect(await reader.drainForRecovery(generation: UUID()).status == .completed)
#expect(probe.graph.tasks[.init(thread: "main", turn: "root")]?.state == .running)
#expect(await reader.stop())
#expect(try await !logs.page().entries.contains { $0.method == "thread/items/list" })
#expect(try directory.historyRecords().allSatisfy { $0.context?.method != "thread/items/list" })
try server.finish()
}
@Test(arguments: [false, true])
func invalidHistoryCursorOrTurnFailsWithoutAcceptingPage(wrongTurn: Bool) async throws {
let server = try SharedServerFixture { peer in
try Self.initialize(peer)
let request = try peer.readMessage()
try peer.reply(to: request, result: [
"data": [["turnId": wrongTurn ? "other" : "root", "item": ["id": "item", "type": "commandExecution"]]],
"nextCursor": wrongTurn ? "next" : "cursor"
])
}
defer { server.close() }
let backfill = AppServerActivityBackfill(socketURL: server.url, logStorage: nil)
await #expect(throws: CodexStatusError.self) {
try await backfill.readPage(reference: .init(threadID: "main", turnID: "root"), cursor: "cursor", limit: 20, timeout: 3)
}
try server.finish()
}
}