CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
fix: 修复防睡眠状态恢复与自动重置重试
Bob9582b613bdf2
diff --git a/.swiftlint.yml b/.swiftlint.ymlindex 17a4b91..36a2b09 100644--- a/.swiftlint.yml+++ b/.swiftlint.yml@@ -1,6 +1,7 @@included:- CodexBar- CodexBarTests+ - CodexBarHelperTestsline_length:warning: 180diff --git a/AGENTS.md b/AGENTS.mdindex 0fba9d3..258fa59 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -54,7 +54,7 @@## 项目结构与模块组织-CodexBar 是面向 macOS 15+ 的 `LSUIElement` 菜单栏应用,使用 Swift 6, SwiftUI, AppKit 和 MVVM。工程只有 `CodexBar` scheme,包含主 App、`CodexBarHelper` 和 `CodexBarTests` 三个 target。+CodexBar 是面向 macOS 的 `LSUIElement` 菜单栏应用,使用 Swift 6, SwiftUI, AppKit 和 MVVM。工程只有 `CodexBar` scheme,包含主 App、`CodexBarHelper`、`CodexBarTests` 和 `CodexBarHelperTests` 四个 target。`CodexBar/` 按 `App/` `Views/` `Controllers/` `Models/` `Services/` 和 `Resources/` 分层。root LaunchDaemon 位于 `CodexBarHelper/` 目录,跨 target XPC 接口位于 `Shared/` 目录。`Scripts/` 提供发布和 helper 清理工具,`Images/` 存放 README 资源。@@ -130,8 +130,8 @@ CodexBar 是面向 macOS 15+ 的 `LSUIElement` 菜单栏应用,使用 Swift 6,- helper 只接受有限时间戳,维护单一的系统唤醒计划;目标变化、功能关闭、App 退出、对应连接断开或 helper 启动时必须收敛并清理计划- 修改唤醒事件的归属或类型时,必须考虑旧版本遗留事件的清理兼容性- 异常会话保护跟随防睡眠开关,只判定非匿名运行中任务,等待批准任务不参与判定-- 活动连接初始化、系统睡眠、唤醒恢复或数据源不可用期间暂停异常会话判定,数据恢复后执行无通知对账-- 主动排空活动读取是屏障,每个调用方必须等待一轮在本次请求之后开始的读取;唤醒后只有该轮读取成功,才能执行生命周期对账并恢复保护判定+- 活动连接初始化、系统睡眠、唤醒恢复或数据源不可用期间暂停异常会话判定,数据恢复后执行无通知核对+- 主动排空活动读取是屏障,每个调用方必须等待一轮在本次请求之后开始的读取;唤醒后只有该轮读取成功,才能执行生命周期核对并恢复保护判定- reader 更换时丢弃旧结果,数据源不可用或任务取消时不得使用旧快照继续判定### 数据语义与兼容性@@ -143,7 +143,7 @@ CodexBar 是面向 macOS 15+ 的 `LSUIElement` 菜单栏应用,使用 Swift 6,## 测试规范-`CodexBarTests` 使用 Swift Testing,无 App 宿主,直接编译 `CodexBar/` 与 `Shared/` 源码。测试 target 独有的 `CODEXBAR_TESTING` 条件只移除 `@main`,不启动 App、Codex、CloudKit 或 helper。文件测试使用独立临时目录,偏好测试使用独立 `UserDefaults` suite,禁止读写真实用户数据。仓库没有覆盖率门槛。+`CodexBarTests` 使用 Swift Testing,无 App 宿主,直接编译 `CodexBar/` 与 `Shared/` 源码。测试 target 独有的 `CODEXBAR_TESTING` 条件只移除 `@main`,不启动 App、Codex、CloudKit 或 helper。文件测试使用独立临时目录,偏好测试使用独立 `UserDefaults` suite,禁止读写真实用户数据。`CodexBarHelperTests` 独立编译 helper 与 `Shared/` 源码,排除 `main.swift`,通过模拟睡眠操作和内存存储验证 helper,不启动 root 服务或修改系统状态。仓库没有覆盖率门槛。每次代码改动至少应完成构建和单元测试,运行 `swiftformat` 和 `swiftlint` 两项检查,并手动验证受影响流程。菜单、窗口焦点、活动采集、同步、通知和防睡眠改动必须说明手动验证场景。Debug 与 Release 使用不同 App 和 helper bundle ID,排查时不要混用。diff --git a/CodexBar.xcodeproj/project.pbxproj b/CodexBar.xcodeproj/project.pbxprojindex 1b86f2c..62ed05b 100644--- a/CodexBar.xcodeproj/project.pbxproj+++ b/CodexBar.xcodeproj/project.pbxproj@@ -3,7 +3,7 @@archiveVersion = 1;classes = {};- objectVersion = 100;+ objectVersion = 110;objects = {/* Begin PBXBuildFile section */@@ -47,6 +47,7 @@C449FB5030203E0000ED2123 /* Version.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Version.xcconfig; sourceTree = "<group>"; };C4A0FD952FD9302E000263A7 /* CodexBar Debug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CodexBar Debug.app"; sourceTree = BUILT_PRODUCTS_DIR; };D10000000000000000000002 /* CodexBarTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = CodexBarTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };+ E10000000000000000000002 /* CodexBarHelperTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = CodexBarHelperTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };/* End PBXFileReference section *//* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */@@ -65,6 +66,13 @@);target = D10000000000000000000010 /* CodexBarTests */;};+ E10000000000000000000003 /* Exceptions for "CodexBarHelper" folder in "CodexBarHelperTests" target */ = {+ isa = PBXFileSystemSynchronizedBuildFileExceptionSet;+ membershipExceptions = (+ main.swift,+ );+ target = E10000000000000000000010 /* CodexBarHelperTests */;+ };/* End PBXFileSystemSynchronizedBuildFileExceptionSet section *//* Begin PBXFileSystemSynchronizedGroupBuildPhaseMembershipExceptionSet section */@@ -91,6 +99,7 @@C449FB3A3020367500ED2123 /* CodexBarHelper */ = {isa = PBXFileSystemSynchronizedRootGroup;exceptions = (+ E10000000000000000000003 /* Exceptions for "CodexBarHelper" folder in "CodexBarHelperTests" target */,C449FB4C302038A300ED2123 /* Exceptions for "CodexBarHelper" folder in "Copy LaunchDaemons" phase from "CodexBar" target */,);path = CodexBarHelper;@@ -106,6 +115,11 @@path = CodexBarTests;sourceTree = "<group>";};+ E10000000000000000000004 /* CodexBarHelperTests */ = {+ isa = PBXFileSystemSynchronizedRootGroup;+ path = CodexBarHelperTests;+ sourceTree = "<group>";+ };/* End PBXFileSystemSynchronizedRootGroup section *//* Begin PBXFrameworksBuildPhase section */@@ -126,6 +140,11 @@D10000000000000000000001 /* Sparkle in Frameworks */,);};+ E10000000000000000000005 /* Frameworks */ = {+ isa = PBXFrameworksBuildPhase;+ files = (+ );+ };/* End PBXFrameworksBuildPhase section *//* Begin PBXGroup section */@@ -142,6 +161,7 @@children = (9E664A4C2FDD47530016B96E /* CodexBar */,D10000000000000000000004 /* CodexBarTests */,+ E10000000000000000000004 /* CodexBarHelperTests */,C449FB4E30203A1100ED2123 /* Shared */,C449FB3A3020367500ED2123 /* CodexBarHelper */,C449FB5130203E0000ED2123 /* Config */,@@ -154,6 +174,7 @@children = (C4A0FD952FD9302E000263A7 /* CodexBar Debug.app */,D10000000000000000000002 /* CodexBarTests.xctest */,+ E10000000000000000000002 /* CodexBarHelperTests.xctest */,B10000000000000000000014 /* CodexBarHelper */,);name = Products;@@ -230,6 +251,25 @@productReference = D10000000000000000000002 /* CodexBarTests.xctest */;productType = "com.apple.product-type.bundle.unit-test";};+ E10000000000000000000010 /* CodexBarHelperTests */ = {+ isa = PBXNativeTarget;+ buildConfigurationList = E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperTests" */;+ buildPhases = (+ E10000000000000000000006 /* Sources */,+ E10000000000000000000005 /* Frameworks */,+ );+ buildRules = (+ );+ fileSystemSynchronizedGroups = (+ C449FB3A3020367500ED2123 /* CodexBarHelper */,+ C449FB4E30203A1100ED2123 /* Shared */,+ E10000000000000000000004 /* CodexBarHelperTests */,+ );+ name = CodexBarHelperTests;+ productName = CodexBarHelperTests;+ productReference = E10000000000000000000002 /* CodexBarHelperTests.xctest */;+ productType = "com.apple.product-type.bundle.unit-test";+ };/* End PBXNativeTarget section *//* Begin PBXProject section */@@ -261,11 +301,12 @@packageReferences = (C42A52EF2FDACDEC004A2B53 /* XCRemoteSwiftPackageReference "Sparkle" */,);- preferredProjectObjectVersion = 100;+ preferredProjectObjectVersion = 110;productRefGroup = C4A0FD962FD9302E000263A7 /* Products */;projectDirPath = "";projectRoot = "";targets = (+ E10000000000000000000010 /* CodexBarHelperTests */,D10000000000000000000010 /* CodexBarTests */,C4A0FD942FD9302E000263A7 /* CodexBar */,B10000000000000000000031 /* CodexBarHelper */,@@ -302,6 +343,11 @@files = ();};+ E10000000000000000000006 /* Sources */ = {+ isa = PBXSourcesBuildPhase;+ files = (+ );+ };/* End PBXSourcesBuildPhase section *//* Begin PBXTargetDependency section */@@ -586,6 +632,34 @@};name = Release;};+ E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperTests" */ = {+ isa = XCBuildConfiguration;+ buildSettings = {+ CODE_SIGN_STYLE = Automatic;+ ENABLE_APP_SANDBOX = NO;+ GENERATE_INFOPLIST_FILE = YES;+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.tests;+ PRODUCT_NAME = "$(TARGET_NAME)";+ SKIP_INSTALL = YES;+ SWIFT_EMIT_LOC_STRINGS = NO;+ SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;+ };+ name = Debug;+ };+ E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperTests" */ = {+ isa = XCBuildConfiguration;+ buildSettings = {+ CODE_SIGN_STYLE = Automatic;+ ENABLE_APP_SANDBOX = NO;+ GENERATE_INFOPLIST_FILE = YES;+ PRODUCT_BUNDLE_IDENTIFIER = app.zabrian.codexbar.helper.tests;+ PRODUCT_NAME = "$(TARGET_NAME)";+ SKIP_INSTALL = YES;+ SWIFT_EMIT_LOC_STRINGS = NO;+ SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;+ };+ name = Release;+ };/* End XCBuildConfiguration section *//* Begin XCConfigurationList section */@@ -621,6 +695,14 @@);defaultConfigurationName = Release;};+ E10000000000000000000011 /* Build configuration list for PBXNativeTarget "CodexBarHelperTests" */ = {+ isa = XCConfigurationList;+ buildConfigurations = (+ E10000000000000000000012 /* Debug configuration for PBXNativeTarget "CodexBarHelperTests" */,+ E10000000000000000000013 /* Release configuration for PBXNativeTarget "CodexBarHelperTests" */,+ );+ defaultConfigurationName = Release;+ };/* End XCConfigurationList section *//* Begin XCRemoteSwiftPackageReference section */diff --git a/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme b/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcschemeindex eae733b..e3e9cb1 100644--- a/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme+++ b/CodexBar.xcodeproj/xcshareddata/xcschemes/CodexBar.xcscheme@@ -41,6 +41,14 @@ReferencedContainer = "container:CodexBar.xcodeproj"></BuildableReference></TestableReference>+ <TestableReference skipped = "NO" parallelizable = "NO">+ <BuildableReference BuildableIdentifier = "primary"+ BlueprintIdentifier = "E10000000000000000000010"+ BuildableName = "CodexBarHelperTests.xctest"+ BlueprintName = "CodexBarHelperTests"+ ReferencedContainer = "container:CodexBar.xcodeproj">+ </BuildableReference>+ </TestableReference></Testables></TestAction><LaunchActiondiff --git a/CodexBar/Controllers/CodexBarAppDelegate.swift b/CodexBar/Controllers/CodexBarAppDelegate.swiftindex ea7ba18..7dc7f6f 100644--- a/CodexBar/Controllers/CodexBarAppDelegate.swift+++ b/CodexBar/Controllers/CodexBarAppDelegate.swift@@ -142,6 +142,7 @@ final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {NSApplication.shared.reply(toApplicationShouldTerminate: false)return}+ autoResetController?.prepareForTermination()let success = await keepAliveController.prepareForTermination()guard !Task.isCancelled else {return@@ -151,6 +152,9 @@ final class CodexBarAppDelegate: NSObject, NSApplicationDelegate {AppLog.app.error("退出前请求日志写入失败")}}+ if !success {+ autoResetController?.resumeAfterTerminationCancellation()+ }terminationPreparationTask = nilhasPreparedForTermination = successNSApplication.shared.reply(toApplicationShouldTerminate: success)diff --git a/CodexBar/Models/CodexQuotaModels.swift b/CodexBar/Models/CodexQuotaModels.swiftindex 04d5464..b37f342 100644--- a/CodexBar/Models/CodexQuotaModels.swift+++ b/CodexBar/Models/CodexQuotaModels.swift@@ -255,6 +255,7 @@ nonisolated struct ResetCreditConsumeResult: Sendable {nonisolated enum AutoResetServiceError: Error, Sendable {case accountChanged+ case deadlineReached}/// app-server 返回的单个 limit, primary/secondary 可能独立缺失diff --git a/CodexBar/Services/Activity/ActivityMonitor.swift b/CodexBar/Services/Activity/ActivityMonitor.swiftindex 247fc16..15e89af 100644--- a/CodexBar/Services/Activity/ActivityMonitor.swift+++ b/CodexBar/Services/Activity/ActivityMonitor.swift@@ -550,7 +550,7 @@ final class ActivityMonitor: ObservableObject {}publishWaitingApprovalTransitions(waitingTaskKeys)if !pendingTerminalTasks.isEmpty {- // 新进入终态确认窗口的任务立即查询, 不等待下次周期对账+ // 新进入终态确认窗口的任务立即查询, 不等待下次周期核对refreshSessionLifecycleNow()} else if events.contains(where: { $0.eventKind == .turnCompleted }) {refreshSessionLifecycleNow()diff --git a/CodexBar/Services/Activity/AppServerActivityReader.swift b/CodexBar/Services/Activity/AppServerActivityReader.swiftindex 06e132a..395c4d5 100644--- a/CodexBar/Services/Activity/AppServerActivityReader.swift+++ b/CodexBar/Services/Activity/AppServerActivityReader.swift@@ -273,7 +273,7 @@ actor AppServerActivityReader {for id in candidates {try checkGeneration(current)try await reconcileThread(id, loaded: loaded, bootstrap: bootstrap, generation: current)- // 日常对账分轮执行, 强制排空则等待本轮完整覆盖+ // 日常核对分轮执行, 强制排空则等待本轮完整覆盖if !forced, ContinuousClock.now >= deadline {break}diff --git a/CodexBar/Services/Activity/AppServerActivityReducer.swift b/CodexBar/Services/Activity/AppServerActivityReducer.swiftindex 18172f0..4b9def2 100644--- a/CodexBar/Services/Activity/AppServerActivityReducer.swift+++ b/CodexBar/Services/Activity/AppServerActivityReducer.swift@@ -1,6 +1,6 @@import Foundation-/// 将协议事件映射为既有业务阶段, 快照对账与实时统计分别处理+/// 将协议事件映射为既有业务阶段, 快照核对与实时统计分别处理nonisolated struct AppServerActivityReducer {var threads: [String: ActivityThread] = [:]var states: [ActivityTurnReference: SessionLifecycleState] = [:]diff --git a/CodexBar/Services/AppServer/AccountSession.swift b/CodexBar/Services/AppServer/AccountSession.swiftindex d149721..2fa514f 100644--- a/CodexBar/Services/AppServer/AccountSession.swift+++ b/CodexBar/Services/AppServer/AccountSession.swift@@ -3,7 +3,6 @@ import os/// 账户连接负责业务解码与重试, 传输和请求日志复用共享 WebSocketfinal nonisolated class AccountSession {- private typealias EncodedMessage = (data: Data, text: String)private let transport: AppServerSessionprivate let timeout: TimeIntervalprivate let logStorage: AppServerLogStore?@@ -69,9 +68,8 @@ final nonisolated class AccountSession {}func notify(_ method: String, params: [String: Any]? = nil) throws {- let encoded = try encodeMessage(method: method, id: nil, params: params)-- try transport.notify(encoded.data)+ let data = try AppServerRPC.encode(method: method, id: nil, params: params)+ try transport.notify(data)}func request<Response: Decodable>(@@ -111,28 +109,20 @@ final nonisolated class AccountSession {params: [String: Any]? = nil,as type: Response.Type) throws -> Response {+ try AppServerRequestBudget.checkCurrent()let id = nextIDnextID += 1- let encoded = try encodeMessage(method: method, id: id, params: params)+ let payload = try AppServerRPC.encode(method: method, id: id, params: params)do {- let data = try transport.exchange(encoded.data, id: id, timeout: timeout)- return try decodeResponse(data, as: type)+ let data = try transport.exchange(payload, id: id, timeout: timeout)+ return try AppServerRPC.decode(data, as: type)} catch {- if let failure = error as? CodexStatusError, failure.isTransportFailure {+ if error is CancellationError || (error as? CodexStatusError)?.isTransportFailure == true {close()}throw error}}-- private func encodeMessage(method: String, id: Int?, params: [String: Any]?) throws -> EncodedMessage {- let data = try AppServerRPC.encode(method: method, id: id, params: params)- return (data, String(bytes: data, encoding: .utf8) ?? "")- }-- private func decodeResponse<Response: Decodable>(_ data: Data, as type: Response.Type) throws -> Response {- try AppServerRPC.decode(data, as: type)- }}private nonisolated struct InitializeResult: Decodable {diff --git a/CodexBar/Services/AppServer/AppServerRequestBudget.swift b/CodexBar/Services/AppServer/AppServerRequestBudget.swiftnew file mode 100644index 0000000..c67ff5b--- /dev/null+++ b/CodexBar/Services/AppServer/AppServerRequestBudget.swift@@ -0,0 +1,35 @@+import Foundation++/// 多次读取和重连共享同一预算, 单调时钟防止系统时间回拨延长请求+nonisolated struct AppServerRequestBudget: Sendable {+ @TaskLocal static var current: AppServerRequestBudget?++ let wallDeadline: Date+ let deadline: ContinuousClock.Instant++ init(deadline: Date, now: Date = Date()) {+ wallDeadline = deadline+ self.deadline = ContinuousClock.now.advanced(by: .seconds(max(0, deadline.timeIntervalSince(now))))+ }++ private init(wallDeadline: Date, deadline: ContinuousClock.Instant) {+ self.wallDeadline = wallDeadline+ self.deadline = deadline+ }++ func constrained(to date: Date, now: Date = Date()) -> Self {+ Self(wallDeadline: min(wallDeadline, date), deadline: min(deadline, ContinuousClock.now.advanced(by: .seconds(max(0, date.timeIntervalSince(now))))))+ }++ func check() throws {+ try Task.checkCancellation()+ guard Date() < wallDeadline, ContinuousClock.now < deadline else {+ throw CodexStatusError.serverTimeout+ }+ }++ static func checkCurrent() throws {+ try Task.checkCancellation()+ try current?.check()+ }+}diff --git a/CodexBar/Services/AppServer/AppServerSession.swift b/CodexBar/Services/AppServer/AppServerSession.swiftindex 7e4b96a..80f0341 100644--- a/CodexBar/Services/AppServer/AppServerSession.swift+++ b/CodexBar/Services/AppServer/AppServerSession.swift@@ -23,6 +23,7 @@ final nonisolated class AppServerSession {private let socketPath: Stringprivate let connectionName: Stringprivate let retainsNotifications: Bool+ private var exchangeDeadline: ContinuousClock.Instant?var isOpen: Bool {descriptor >= 0}@@ -56,7 +57,7 @@ final nonisolated class AppServerSession {if result != 0 {let code = errnoguard code == EINPROGRESS else { throw AppServerConnectionError(code: code) }- guard try ready(Int16(POLLOUT), before: Date().addingTimeInterval(2)) else {+ guard try ready(Int16(POLLOUT), before: ContinuousClock.now.advanced(by: .seconds(2))) else {throw CodexStatusError.serverTimeout}var socketError: Int32 = 0@@ -141,7 +142,7 @@ final nonisolated class AppServerSession {func poll(_ request: PendingRequest) throws -> RequestPoll {try Task.checkCancellation()guard ContinuousClock.now < request.deadline else { throw CodexStatusError.serverTimeout }- guard let data = try receive(before: Date().addingTimeInterval(0.02), matchingResponseID: request.id) else { return .waiting }+ guard let data = try receive(before: ContinuousClock.now.advanced(by: .seconds(0.02)), matchingResponseID: request.id) else { return .waiting }guard let object = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {throw CodexStatusError.invalidServerResponse}@@ -167,6 +168,9 @@ final nonisolated class AppServerSession {/// 账户和活动连接共用帧协议与请求日志, 业务解码由调用方负责func exchange(_ payload: Data, id: Int, timeout: TimeInterval) throws -> Data {+ try AppServerRequestBudget.checkCurrent()+ exchangeDeadline = ContinuousClock.now.advanced(by: .seconds(timeout))+ defer { exchangeDeadline = nil }let request = try JSONSerialization.jsonObject(with: payload) as? [String: Any]let method = request?["method"] as? String ?? "unknown"let text = String(data: payload, encoding: .utf8) ?? ""@@ -193,8 +197,9 @@ final nonisolated class AppServerSession {private func receiveResponse(_ payload: Data, id: Int, timeout: TimeInterval) throws -> Data {try sendFrame(payload, opcode: 1)- let deadline = Date().addingTimeInterval(timeout)- while Date() < deadline {+ let deadline = exchangeDeadline ?? ContinuousClock.now.advanced(by: .seconds(timeout))+ while ContinuousClock.now < deadline {+ try AppServerRequestBudget.checkCurrent()guard let data = try receive(before: deadline, matchingResponseID: id),let object = try JSONSerialization.jsonObject(with: data) as? [String: Any] else { continue }if object["id"] as? Int == id, object["result"] != nil || object["error"] != nil {@@ -227,7 +232,7 @@ final nonisolated class AppServerSession {return notifications.removeFirst()}do {- return try receive(before: Date().addingTimeInterval(0.05))+ return try receive(before: ContinuousClock.now.advanced(by: .seconds(0.05)))} catch {logStorage?.recordFailure(method: "connection/receive", message: error.localizedDescription, connection: connectionName, source: .connection)throw error@@ -237,7 +242,7 @@ final nonisolated class AppServerSession {private func handshake() throws {let key = Data((0 ..< 16).map { _ in UInt8.random(in: .min ... .max) }).base64EncodedString()let text = "GET / HTTP/1.1\r\nHost: localhost\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: \(key)\r\nSec-WebSocket-Version: 13\r\n\r\n"- let deadline = Date().addingTimeInterval(5)+ let deadline = ContinuousClock.now.advanced(by: .seconds(5))let token = logStorage?.beginRequest(method: "websocket/handshake", payload: text, connection: connectionName, source: .connection)var header = Data()do {@@ -281,7 +286,7 @@ final nonisolated class AppServerSession {frame.append(contentsOf: mask)frame.append(contentsOf: payload.enumerated().map { $0.element ^ mask[$0.offset % 4] })do {- try write(frame, before: Date().addingTimeInterval(5))+ try write(frame, before: ContinuousClock.now.advanced(by: .seconds(5)))if opcode != 1 {logStorage?.recordSent(method: controlMethod(opcode), payload: framePayload(payload), connection: connectionName)}@@ -298,9 +303,9 @@ final nonisolated class AppServerSession {}}- private func receive(before deadline: Date, matchingResponseID: Int? = nil) throws -> Data? {+ private func receive(before deadline: ContinuousClock.Instant, matchingResponseID: Int? = nil) throws -> Data? {guard try ready(Int16(POLLIN), before: deadline) else { return nil }- let frameDeadline = Date().addingTimeInterval(10)+ let frameDeadline = ContinuousClock.now.advanced(by: .seconds(10))var message = Data()var fragmented = falsewhile true {@@ -388,12 +393,14 @@ final nonisolated class AppServerSession {String(data: data, encoding: .utf8) ?? "base64:" + data.base64EncodedString()}- private func ready(_ events: Int16, before deadline: Date) throws -> Bool {+ private func ready(_ events: Int16, before deadline: ContinuousClock.Instant) throws -> Bool {+ try AppServerRequestBudget.checkCurrent()guard descriptor >= 0 else { throw CodexStatusError.serverConnectionClosed }+ let deadline = min(deadline, exchangeDeadline ?? deadline, AppServerRequestBudget.current?.deadline ?? deadline)var descriptor = pollfd(fd: descriptor, events: events, revents: 0)- while Date() < deadline {- try Task.checkCancellation()- let result = Darwin.poll(&descriptor, 1, Int32(max(1, min(100, deadline.timeIntervalSinceNow * 1000))))+ while ContinuousClock.now < deadline {+ try AppServerRequestBudget.checkCurrent()+ let result = Darwin.poll(&descriptor, 1, Int32(max(1, min(100, TimeInterval(ContinuousClock.now.duration(to: deadline)) * 1000))))if result < 0, errno == EINTR {continue}@@ -409,7 +416,7 @@ final nonisolated class AppServerSession {return false}- private func read(_ count: Int, before deadline: Date) throws -> Data {+ private func read(_ count: Int, before deadline: ContinuousClock.Instant) throws -> Data {var result = Data()var buffer = [UInt8](repeating: 0, count: min(count, 65536))while result.count < count {@@ -424,7 +431,7 @@ final nonisolated class AppServerSession {return result}- private func write(_ data: Data, before deadline: Date) throws {+ private func write(_ data: Data, before deadline: ContinuousClock.Instant) throws {var offset = 0while offset < data.count {guard try ready(Int16(POLLOUT), before: deadline) else { throw CodexStatusError.serverTimeout }diff --git a/CodexBar/Services/CodexStatus/AutoResetController.swift b/CodexBar/Services/CodexStatus/AutoResetController.swiftindex 314e397..cd3cd8d 100644--- a/CodexBar/Services/CodexStatus/AutoResetController.swift+++ b/CodexBar/Services/CodexStatus/AutoResetController.swift@@ -4,823 +4,458 @@ import Foundationimport IOKitimport os-/// 自动重置的本机状态机-/// 计划执行前通过 helper 预约系统唤醒, 唤醒后仍经新鲜读取决定是否使用+@MainActor+protocol AutoResetWakeActivity: AnyObject {+ func beginPreventingIdleSleep() -> IOReturn+ func endPreventingIdleSleep() -> IOReturn+}++extension SystemSleepService: AutoResetWakeActivity {}++/// 定时器只负责触发, 凭证预算和执行结果由控制器拥有@MainActorfinal class AutoResetController {- private enum ScheduledKind: Equatable {- case threshold- case retry- }+ struct Dependencies {+ var read: (AppServerRequestBudget) async throws -> AutoResetRead+ var consume: (AutoResetCandidate, String, AppServerRequestBudget) async throws -> ResetCreditConsumeResult+ var setRequested: (Bool) -> Void+ var setWakeDate: (Date?) -> Void+ var succeeded: (Int?, String) -> Void+ var failed: (AutoResetFailureNotice, String) -> Void+ var refresh: () -> Void+ var makeWakeActivity: () -> any AutoResetWakeActivity = {+ SystemSleepService(sleepAssertionName: "CodexBar - Automatic Reset")+ }- private enum RetryCause: Equatable {- case transient- case detailsUnavailable- case nothingToReset- case noCredit+ var now: () -> Date = Date.init+ var sleep: (Date) async throws -> Void = { date in+ try await Task.sleep(for: .seconds(max(0, date.timeIntervalSinceNow)))+ }}- private enum BlockReason: Equatable {- case authentication- case permanent+ private enum BlockReason { case authentication, permanent }++ private struct Record {+ var schedule = AutoResetSchedule()+ var expirationDate: Date+ var block: BlockReason?+ var consumed = false+ var notifiedExpiration: Date?}private struct Target {let accountIdentity: Stringlet candidate: AutoResetCandidate- let key: String-- var idempotencyKey: String {- AutoResetIdentity.idempotencyKey(forCreditID: candidate.id)+ var key: String {+ AutoResetIdentity.notificationToken(accountIdentity: accountIdentity, creditID: candidate.id)}}- private struct RetryWindow {- let targetKey: String- let deadline: Date+ private struct Evaluation {+ let target: Target+ let attempt: AutoResetSchedule.Attempt}- private static let retryDelays: [TimeInterval] = [15, 30, 60, 120, 300]- private static let retryWindowDuration: TimeInterval = 5 * 60- private static let finalNothingToResetWindow: TimeInterval = 10 * 60- private static let finalNothingToResetDelay: TimeInterval = 60-private let settings: AutoResetSettings- private let statusViewModel: CodexStatusViewModel- private let service: CodexStatusService- private let notificationService: NotificationService- private let keepAliveController: KeepAliveController- private let wakeActivity = SystemSleepService(- sleepAssertionName: "CodexBar - Automatic Reset"- )-+ private let snapshots: AnyPublisher<CodexQuotaSnapshot?, Never>+ private let dependencies: Dependenciesprivate var cancellables = Set<AnyCancellable>()private var scheduledTask: Task<Void, Never>?private var evaluationTask: Task<Void, Never>?- private var settingsActivationTask: Task<Void, Never>?- private var evaluationGeneration = 0- private var pendingEvaluation = false- private var latestSnapshot: CodexQuotaSnapshot?+ private var activationTask: Task<Void, Never>?+ private var generation = 0+ private var pendingTrigger: LogTrigger?private var target: Target?- private var retryWindow: RetryWindow?- private var retryIndex = 0- private var consumedTargetKeys = Set<String>()- private var expiredTargetDates: [String: Date] = [:]- private var blockedTargets: [String: BlockReason] = [:]+ private var accountIdentity: String?+ private var records: [String: Record] = [:]private var isStarted = false+ private var isSleeping = false+ private var isPreparingForTermination = false+ private(set) var scheduledDate: Date?+ private(set) var wakeDate: Date?- init(+ convenience init(settings: AutoResetSettings,statusViewModel: CodexStatusViewModel,service: CodexStatusService,notificationService: NotificationService,keepAliveController: KeepAliveController) {+ self.init(settings: settings, snapshots: statusViewModel.$snapshot.eraseToAnyPublisher(), dependencies: Dependencies(+ read: { try await service.readCreditsForAutoReset(budget: $0) },+ consume: { candidate, account, budget in+ try await service.consumeResetCredit(+ id: candidate.id,+ idempotencyKey: AutoResetIdentity.idempotencyKey(forCreditID: candidate.id),+ expectedAccountIdentity: account,+ expirationDate: candidate.expirationDate,+ budget: budget+ )+ },+ setRequested: { keepAliveController.setAutoResetRequested($0) },+ setWakeDate: { keepAliveController.setAutoResetWakeDate($0) },+ succeeded: { notificationService.notifyAutoResetSucceeded(remainingCount: $0, dedupToken: $1) },+ failed: { notificationService.notifyAutoResetFailed(reason: $0, dedupToken: $1) },+ refresh: { statusViewModel.refreshAfterCurrent(trigger: .autoReset) }+ ))+ }++ init(settings: AutoResetSettings, snapshots: AnyPublisher<CodexQuotaSnapshot?, Never>, dependencies: Dependencies) {self.settings = settings- self.statusViewModel = statusViewModel- self.service = service- self.notificationService = notificationService- self.keepAliveController = keepAliveController+ self.snapshots = snapshots+ self.dependencies = dependencies}deinit {scheduledTask?.cancel()evaluationTask?.cancel()- settingsActivationTask?.cancel()+ activationTask?.cancel()}func start() {- guard !isStarted else {- return- }+ guard !isStarted else { return }isStarted = true- keepAliveController.setAutoResetRequested(settings.isEnabled)-- statusViewModel.$snapshot- .sink { [weak self] snapshot in- self?.handleSnapshot(snapshot)- }- .store(in: &cancellables)-- settings.$isEnabled- .dropFirst()- .sink { [weak self] enabled in- self?.handleEnabledChange(enabled)- }- .store(in: &cancellables)-- settings.$leadTime- .dropFirst()- .sink { [weak self] leadTime in- self?.handleLeadTimeChange(leadTime)- }- .store(in: &cancellables)-- NSWorkspace.shared.notificationCenter- .publisher(for: NSWorkspace.didWakeNotification)- .receive(on: DispatchQueue.main)- .sink { [weak self] _ in- self?.requestEvaluation(trigger: .wake)- }- .store(in: &cancellables)-- if settings.isEnabled {- requestEvaluation(trigger: .launch)- }+ dependencies.setRequested(settings.isEnabled)+ snapshots.sink { [weak self] in self?.handleSnapshot($0) }.store(in: &cancellables)+ settings.$isEnabled.dropFirst().sink { [weak self] in self?.handleEnabledChange($0) }.store(in: &cancellables)+ settings.$leadTime.dropFirst().receive(on: DispatchQueue.main).sink { [weak self] _ in+ guard let self, settings.isEnabled else { return }+ invalidateEvaluation()+ requestEvaluation(trigger: .settings)+ }.store(in: &cancellables)+ NSWorkspace.shared.notificationCenter.publisher(for: NSWorkspace.willSleepNotification)+ .receive(on: DispatchQueue.main).sink { [weak self] _ in self?.handleSleep() }.store(in: &cancellables)+ NSWorkspace.shared.notificationCenter.publisher(for: NSWorkspace.didWakeNotification)+ .receive(on: DispatchQueue.main).sink { [weak self] _ in self?.handleWake() }.store(in: &cancellables)+ NotificationCenter.default.publisher(for: .NSSystemClockDidChange)+ .receive(on: DispatchQueue.main).sink { [weak self] _ in self?.handleClockChange() }.store(in: &cancellables)+ requestEvaluation(trigger: .launch)}func stop() {- guard isStarted else {- return- }isStarted = false- keepAliveController.setAutoResetRequested(false)+ dependencies.setRequested(false)cancellables.removeAll()cancelWork()target = nil}+ func prepareForTermination() {+ isPreparingForTermination = true+ cancelWork()+ }++ func resumeAfterTerminationCancellation() {+ isPreparingForTermination = false+ requestEvaluation(trigger: .launch)+ }++ func handleSleep() {+ isSleeping = true+ invalidateEvaluation()+ cancelTimer()+ // 系统睡眠不撤销首次执行和最终复查的唤醒预约+ refreshSchedule()+ }++ func handleWake() {+ isSleeping = false+ requestEvaluation(trigger: .wake)+ }++ func handleClockChange() {+ invalidateEvaluation()+ setWakeDate(nil)+ refreshSchedule()+ requestEvaluation(trigger: .statusRefresh)+ }++ private var isEnabled: Bool {+ isStarted && settings.isEnabled && !isPreparingForTermination+ }++ private var canEvaluate: Bool {+ isEnabled && !isSleeping+ }+private func handleEnabledChange(_ enabled: Bool) {- keepAliveController.setAutoResetRequested(enabled)+ dependencies.setRequested(enabled)guard enabled else {cancelWork()target = nilreturn}-- settingsActivationTask?.cancel()- settingsActivationTask = Task { @MainActor [weak self] in+ activationTask?.cancel()+ activationTask = Task { @MainActor [weak self] in+ // @Published 在 willSet 发值, 等设置提交后再读取await Task.yield()- guard let self,- !Task.isCancelled,- settings.isEnabled else {- return- }-- settingsActivationTask = nil- if let latestSnapshot {- handleSnapshot(latestSnapshot)- }+ guard let self, !Task.isCancelled else { return }+ activationTask = nilrequestEvaluation(trigger: .settings)}}- private func handleLeadTimeChange(_: AutoResetLeadTime) {- guard settings.isEnabled else {- return- }- requestEvaluation(trigger: .settings)- }-private func handleSnapshot(_ snapshot: CodexQuotaSnapshot?) {- latestSnapshot = snapshot- guard settings.isEnabled,- let snapshot,- !snapshot.isRateLimitsStale else {- return+ guard isEnabled, let snapshot, !snapshot.isRateLimitsStale else { return }+ let previousKey = target?.key+ let previousExpiration = target?.candidate.expirationDate+ let identity = AutoResetIdentity.accountIdentity(for: snapshot.account)+ if let accountIdentity, accountIdentity != identity {+ invalidateEvaluation()}-- reconcile(- accountIdentity: AutoResetIdentity.accountIdentity(for: snapshot.account),- availableCount: snapshot.resetCreditsAvailableCount,- candidates: snapshot.autoResetCandidates,- now: Date()- )- scheduleCurrentTargetIfNeeded()+ reconcile(AutoResetRead(accountIdentity: identity, availableCount: snapshot.resetCreditsAvailableCount, candidates: snapshot.autoResetCandidates))+ if let previousKey, previousKey != target?.key || previousExpiration != target?.candidate.expirationDate {+ invalidateEvaluation()+ }+ refreshSchedule()}- private func requestEvaluation(- trigger: LogTrigger,- expectedTargetKey: String? = nil- ) {- guard isStarted, settings.isEnabled else {- return- }+ private func requestEvaluation(trigger: LogTrigger) {+ guard canEvaluate else { return }guard evaluationTask == nil else {- pendingEvaluation = true+ pendingTrigger = triggerreturn}-- let startedAt = Date()- if let retryWindow,- retryWindow.deadline <= startedAt {- finishRetryWindow(ifMatching: retryWindow.targetKey)- if trigger == .retry {- cancelScheduledTask()- return- }- }-- cancelScheduledTask()- evaluationGeneration += 1- let generation = evaluationGeneration+ cancelTimer()+ let generation = generationevaluationTask = Task { @MainActor [weak self] in- guard let self else {- return- }- await performEvaluation(- trigger: trigger,- expectedTargetKey: expectedTargetKey,- startedAt: startedAt- )- finishEvaluation(generation: generation)+ guard let self else { return }+ await performEvaluation(trigger: trigger, generation: generation)+ finishEvaluation()}}- private func finishEvaluation(generation: Int) {- guard generation == evaluationGeneration else {- return- }-+ private func finishEvaluation() {evaluationTask = nil- guard pendingEvaluation else {- scheduleCurrentTargetIfNeeded()- return+ if let trigger = pendingTrigger {+ pendingTrigger = nil+ requestEvaluation(trigger: trigger)}+ refreshSchedule()+ }- pendingEvaluation = false- requestEvaluation(trigger: .retry)+ private func isCurrent(_ generation: Int) -> Bool {+ generation == self.generation && canEvaluate && !Task.isCancelled}- private func performEvaluation(- trigger: LogTrigger,- expectedTargetKey: String?,- startedAt: Date- ) async {- let holdsWakeActivity = beginWakeActivityIfNeeded(trigger: trigger)+ private func performEvaluation(trigger: LogTrigger, generation: Int) async {+ guard isCurrent(generation) else { return }+ let activity = dependencies.makeWakeActivity()+ let holdsAssertion = activity.beginPreventingIdleSleep() == kIOReturnSuccess+ if !holdsAssertion {+ AppLog.app.error("自动重置短时防睡眠建立失败")+ }defer {- endWakeActivityIfNeeded(holdsWakeActivity)+ if holdsAssertion, activity.endPreventingIdleSleep() != kIOReturnSuccess {+ AppLog.app.error("自动重置短时防睡眠释放失败")+ }}-- if let target,- expectedTargetKey == nil || expectedTargetKey == target.key,- thresholdDate(for: target) <= startedAt {- startRetryWindowIfNeeded(for: target, startedAt: startedAt)+ var evaluation = beginDueEvaluation()+ var transientFailure = true+ defer {+ if let evaluation {+ finishAttempt(evaluation, transientFailure: transientFailure, coversFinal: isCurrent(generation))+ }}-- let freshRead: AutoResetReaddo {- freshRead = try await service.readCreditsForAutoReset()- } catch {- guard !Task.isCancelled, settings.isEnabled else {+ let readDeadline = evaluation?.attempt.deadline ?? dependencies.now().addingTimeInterval(60)+ let budget = AppServerRequestBudget(deadline: readDeadline, now: dependencies.now())+ let read = try await dependencies.read(budget)+ guard isCurrent(generation) else { return }+ reconcile(read)+ guard read.candidates != nil else { return }+ guard let currentTarget = target else { return }+ if let evaluation, evaluation.target.key != currentTarget.key {return}- handleRequestFailure(error, windowStartedAt: startedAt)- return- }-- guard !Task.isCancelled, settings.isEnabled else {- return- }-- let now = Date()- reconcile(freshRead, now: now)-- guard freshRead.candidates != nil else {- if target != nil || (freshRead.availableCount ?? 0) > 0 {- scheduleRetry(cause: .detailsUnavailable, windowStartedAt: startedAt)+ if evaluation == nil {+ evaluation = beginDueEvaluation()}- return- }- guard let target else {- return- }- if let expectedTargetKey, expectedTargetKey != target.key {- scheduleCurrentTargetIfNeeded()- return- }- guard blockedTargets[target.key] == nil else {- return- }- guard target.candidate.expirationDate > now else {- finishExpiredTarget(target)- return- }-- let thresholdDate = thresholdDate(for: target)- guard thresholdDate <= now else {- scheduleCurrentTargetIfNeeded()- return+ guard let evaluation, records[evaluation.target.key]?.block == nil else { return }+ let deadline = min(evaluation.attempt.deadline, AutoResetSchedule.cutoff(for: currentTarget.candidate.expirationDate))+ guard dependencies.now() < deadline, isCurrent(generation) else { return }+ updateWakeDate(during: evaluation)+ AppLog.app.notice("自动重置开始: trigger=\(trigger.rawValue, privacy: .public)")+ let result = try await dependencies.consume(+ currentTarget.candidate, currentTarget.accountIdentity,+ budget.constrained(to: deadline, now: dependencies.now())+ )+ transientFailure = false+ handleConsumeResult(result, evaluation: evaluation, isCurrent: isCurrent(generation))+ } catch {+ guard isCurrent(generation) else { return }+ handleFailure(error, evaluation: evaluation)}+ }- startRetryWindowIfNeeded(for: target, startedAt: startedAt)+ private func beginDueEvaluation() -> Evaluation? {+ let now = dependencies.now()+ guard let target, var record = records[target.key], !record.consumed, record.block == nil,+ let attempt = record.schedule.begin(expirationDate: target.candidate.expirationDate, leadTime: settings.leadTime.duration, now: now) else { return nil }+ records[target.key] = record+ let evaluation = Evaluation(target: target, attempt: attempt)+ updateWakeDate(during: evaluation)+ return evaluation+ }- AppLog.app.notice(- "自动重置开始: trigger=\(trigger.rawValue, privacy: .public)"- )- let attemptedTarget = target- do {- let result = try await service.consumeResetCredit(- id: attemptedTarget.candidate.id,- idempotencyKey: attemptedTarget.idempotencyKey,- expectedAccountIdentity: attemptedTarget.accountIdentity- )- handleConsumeResult(result, attemptedTarget: attemptedTarget)- } catch {- handleConsumeFailure(- error,- attemptedTarget: attemptedTarget,- windowStartedAt: startedAt- )+ private func finishAttempt(_ evaluation: Evaluation, transientFailure: Bool, coversFinal: Bool) {+ guard var record = records[evaluation.target.key], !record.consumed else { return }+ record.schedule.finish(evaluation.attempt, transientFailure: transientFailure, leadTime: settings.leadTime.duration, now: dependencies.now())+ if coversFinal {+ record.schedule.coverFinalIfNeeded(evaluation.attempt, expirationDate: record.expirationDate, transientFailure: transientFailure, now: dependencies.now())}+ records[evaluation.target.key] = record}- private func handleConsumeResult(- _ result: ResetCreditConsumeResult,- attemptedTarget: Target- ) {+ private func handleConsumeResult(_ result: ResetCreditConsumeResult, evaluation: Evaluation, isCurrent: Bool) {+ let attempted = evaluation.targetswitch result.outcome {case .reset, .alreadyRedeemed:- consumedTargetKeys.insert(attemptedTarget.key)- expiredTargetDates.removeValue(forKey: attemptedTarget.key)- blockedTargets.removeValue(forKey: attemptedTarget.key)- clearTarget(ifMatching: attemptedTarget.key)-- let refreshedRead = result.refreshedRead- let remainingCount = refreshedRead?.accountIdentity == attemptedTarget.accountIdentity- ? refreshedRead?.availableCount- : nil- notificationService.notifyAutoResetSucceeded(- remainingCount: remainingCount,- dedupToken: attemptedTarget.key- )- AppLog.app.notice(- "自动重置完成: outcome=\(result.outcome.rawValue, privacy: .public)"- )-- if settings.isEnabled,- let refreshedRead,- refreshedRead.accountIdentity == attemptedTarget.accountIdentity {- reconcile(refreshedRead)- scheduleCurrentTargetIfNeeded()+ // 已确认的副作用不能因任务取消丢失, 但旧读取不能重建计划+ var record = records[attempted.key] ?? Record(expirationDate: attempted.candidate.expirationDate)+ let wasConsumed = record.consumed+ record.consumed = true+ record.block = nil+ records[attempted.key] = record+ if !wasConsumed {+ let remaining = result.refreshedRead.flatMap { $0.accountIdentity == attempted.accountIdentity ? $0.availableCount : nil }+ dependencies.succeeded(remaining, attempted.key)}- statusViewModel.refreshAfterCurrent(trigger: .autoReset)-- case .nothingToReset, .noCredit:- if let refreshedRead = result.refreshedRead {- reconcile(refreshedRead)+ if target?.key == attempted.key {+ target = nil}-- guard settings.isEnabled,- target?.key == attemptedTarget.key else {- statusViewModel.refreshAfterCurrent(trigger: .autoReset)- return+ if isCurrent, let read = result.refreshedRead {+ reconcile(read)+ }+ dependencies.refresh()+ AppLog.app.notice("自动重置完成: outcome=\(result.outcome.rawValue, privacy: .public)")+ case .nothingToReset, .noCredit:+ guard isCurrent else { return }+ if let read = result.refreshedRead {+ reconcile(read)}-- let cause: RetryCause = result.outcome == .nothingToReset- ? .nothingToReset- : .noCredit- AppLog.app.notice(- "自动重置未完成: outcome=\(result.outcome.rawValue, privacy: .public)"- )- scheduleRetry(cause: cause)-if result.outcome == .noCredit {- statusViewModel.refreshAfterCurrent(trigger: .autoReset)+ dependencies.refresh()}+ AppLog.app.notice("自动重置等待复查: outcome=\(result.outcome.rawValue, privacy: .public)")}}- private func handleConsumeFailure(- _ error: Error,- attemptedTarget: Target,- windowStartedAt: Date- ) {- guard !Task.isCancelled,- settings.isEnabled,- target?.key == attemptedTarget.key else {+ private func handleFailure(_ error: Error, evaluation: Evaluation?) {+ if case AutoResetServiceError.accountChanged = error {+ target = nil+ dependencies.refresh()return}- handleRequestFailure(error, windowStartedAt: windowStartedAt)- }-- private func handleRequestFailure(_ error: Error, windowStartedAt: Date) {- if error is AutoResetServiceError {- clearTarget()- statusViewModel.refreshAfterCurrent(trigger: .autoReset)+ if error is CancellationError || error is AutoResetServiceError {return}-+ guard let key = evaluation?.target.key ?? target?.key else { return }if let error = error as? CodexStatusError {if error.isAuthenticationRequired {- blockCurrentTarget(reason: .authentication)- statusViewModel.refreshAfterCurrent(trigger: .autoReset)- return- }- if error.isProtocolOrParameterFailure {- blockCurrentTarget(reason: .permanent)- return+ records[key]?.block = .authentication+ dependencies.failed(.authentication, key)+ dependencies.refresh()+ } else if error.isProtocolOrParameterFailure {+ records[key]?.block = .permanent+ dependencies.failed(.permanent, key)}-- if scheduleRetry(cause: .transient, windowStartedAt: windowStartedAt) {- AppLog.app.notice("自动重置稍后重试: reason=requestFailed")- }- return+ } else {+ records[key]?.block = .permanent+ dependencies.failed(.permanent, key)}-- blockCurrentTarget(reason: .permanent)}- private func blockCurrentTarget(reason: BlockReason) {- guard let target else {- return- }-- blockedTargets[target.key] = reason- cancelScheduledTask()- resetRetryWindow(ifMatching: target.key)- switch reason {- case .authentication:- notificationService.notifyAutoResetFailed(- reason: .authentication,- dedupToken: target.key- )- AppLog.app.error("自动重置已暂停: reason=authentication")- case .permanent:- notificationService.notifyAutoResetFailed(- reason: .permanent,- dedupToken: target.key- )- AppLog.app.error("自动重置已停止: reason=permanentFailure")- }- }-- @discardableResult- private func scheduleRetry(- cause: RetryCause,- windowStartedAt: Date = Date()- ) -> Bool {- guard settings.isEnabled,- let target,- thresholdDate(for: target) <= windowStartedAt else {- return false- }- guard blockedTargets[target.key] == nil else {- return false- }-- let now = Date()- let remaining = target.candidate.expirationDate.timeIntervalSince(now)- guard remaining > 0 else {- finishExpiredTarget(target)- return false- }-- let retryWindow = startRetryWindowIfNeeded(- for: target,- startedAt: windowStartedAt- )- guard retryWindow.deadline > now else {- scheduleRetryWindowEnd(- at: now,- expectedTargetKey: target.key- )- return false- }+ // MARK: - 新鲜凭证与计划- var delay = nextRetryDelay()- if cause == .nothingToReset, remaining <= Self.finalNothingToResetWindow {- delay = Self.finalNothingToResetDelay- }- delay = min(delay, remaining)- let retryDate = now.addingTimeInterval(delay)- guard retryDate < retryWindow.deadline else {- scheduleRetryWindowEnd(- at: retryWindow.deadline,- expectedTargetKey: target.key- )- return false+ private func reconcile(_ read: AutoResetRead) {+ let now = dependencies.now()+ records = records.filter { $0.value.expirationDate > now.addingTimeInterval(-86400) }+ if accountIdentity != read.accountIdentity {+ target = nil+ accountIdentity = read.accountIdentity}- schedule(- at: retryDate,- kind: .retry,- expectedTargetKey: target.key- )- return true- }-- private func nextRetryDelay() -> TimeInterval {- let index = min(retryIndex, Self.retryDelays.count - 1)- retryIndex += 1- return Self.retryDelays[index]- }-- private func scheduleCurrentTargetIfNeeded() {- guard isStarted,- settings.isEnabled,- evaluationTask == nil,- scheduledTask == nil,- let target,- blockedTargets[target.key] == nil else {+ guard read.availableCount != 0 else { target = nilreturn}-- let thresholdDate = thresholdDate(for: target)- if thresholdDate > Date() {- // 回到正常阈值等待后开始新的重试周期, 避免旧故障影响正式执行- resetRetryWindow()- }- schedule(- at: thresholdDate,- kind: .threshold,- expectedTargetKey: target.key- )- }-- private func schedule(- at date: Date,- kind: ScheduledKind,- expectedTargetKey: String- ) {- cancelScheduledTask(clearsWakeSchedule: false)- keepAliveController.setAutoResetWakeDate(date)- scheduledTask = Task { @MainActor [weak self] in- do {- try await Task.sleep(for: .seconds(max(0, date.timeIntervalSinceNow)))- } catch {- return- }- guard let self, !Task.isCancelled else {- return+ guard let candidates = read.candidates else { return }+ if let target, let expired = candidates.first(where: { $0.id == target.candidate.id && $0.expirationDate <= now }),+ records[target.key]?.notifiedExpiration != expired.expirationDate {+ records[target.key]?.notifiedExpiration = expired.expirationDate+ dependencies.failed(.expired, target.key)+ }+ for candidate in candidates {+ let key = AutoResetIdentity.notificationToken(accountIdentity: read.accountIdentity, creditID: candidate.id)+ var record = records[key] ?? Record(expirationDate: candidate.expirationDate)+ record.expirationDate = candidate.expirationDate+ if record.block == .authentication {+ record.block = nil}-- scheduledTask = nil- requestEvaluation(- trigger: kind == .threshold ? .auto : .retry,- expectedTargetKey: expectedTargetKey- )+ records[key] = record}+ target = candidates.filter { candidate in+ let key = AutoResetIdentity.notificationToken(accountIdentity: read.accountIdentity, creditID: candidate.id)+ return candidate.expirationDate > now && records[key]?.consumed != true && records[key]?.block != .permanent+ }.sorted {+ $0.expirationDate == $1.expirationDate ? $0.id < $1.id : $0.expirationDate < $1.expirationDate+ }.first.map { Target(accountIdentity: read.accountIdentity, candidate: $0) }}- private func scheduleRetryWindowEnd(- at date: Date,- expectedTargetKey: String- ) {- cancelScheduledTask()- // 截止任务占住 scheduledTask, 防止当前评估返回后立即重排已经过去的阈值- // 系统唤醒已由 cancelScheduledTask 清除- scheduledTask = Task { @MainActor [weak self] in- do {- try await Task.sleep(for: .seconds(max(0, date.timeIntervalSinceNow)))- } catch {- return- }- guard let self, !Task.isCancelled else {- return- }-- scheduledTask = nil- finishRetryWindow(ifMatching: expectedTargetKey)- }- }-- private func reconcile(- accountIdentity: String,- availableCount: Int?,- candidates: [AutoResetCandidate]?,- now: Date- ) {- if let target, target.accountIdentity != accountIdentity {- clearTarget()- }-- if availableCount == 0 {- clearTarget()+ private func refreshSchedule() {+ cancelTimer()+ guard isEnabled, let target, var record = records[target.key], record.block == nil, !record.consumed else {+ setWakeDate(nil)return}-- guard let candidates else {+ if evaluationTask != nil {+ let finalDate = target.candidate.expirationDate.addingTimeInterval(-AutoResetSchedule.finalLeadTime)+ setWakeDate(finalDate > dependencies.now() ? finalDate : nil)return}-- if let currentTarget = target,- currentTarget.accountIdentity == accountIdentity {- if let matchingCandidate = candidates.first(where: {- $0.id == currentTarget.candidate.id- }) {- let expirationChanged = matchingCandidate.expirationDate- != currentTarget.candidate.expirationDate- let updatedTarget = makeTarget(- accountIdentity: accountIdentity,- candidate: matchingCandidate- )- target = updatedTarget- if expirationChanged {- // creditId 决定幂等身份, expiresAt 是可变调度数据- // 取消阈值或重试任务, 由当前调用链按新时间重建- cancelScheduledTask()- let direction = matchingCandidate.expirationDate- < currentTarget.candidate.expirationDate ? "earlier" : "later"- AppLog.app.notice(- "自动重置计划已更新: reason=expirationChanged direction=\(direction, privacy: .public)"- )- }- if blockedTargets[currentTarget.key] == .authentication {- blockedTargets.removeValue(forKey: currentTarget.key)- }- if matchingCandidate.expirationDate <= now {- finishExpiredTarget(updatedTarget)- return- }- } else {- // 凭证消失无法区分手动使用 其他设备使用或服务端过期- // 因此只停止本机任务, 不发送自动重置通知- clearTarget()- }- }-- let nextCandidate = candidates- .filter { candidate in- isCandidateEligible(- candidate,- accountIdentity: accountIdentity,- now: now- )- }- .sorted { lhs, rhs in- if lhs.expirationDate != rhs.expirationDate {- return lhs.expirationDate < rhs.expirationDate- }- return lhs.id < rhs.id- }- .first-- guard let nextCandidate else {- return- }-- let nextTarget = makeTarget(- accountIdentity: accountIdentity,- candidate: nextCandidate- )- if expiredTargetDates.removeValue(forKey: nextTarget.key) != nil {- AppLog.app.notice("自动重置计划已恢复: reason=expirationExtended")- }- if target?.key == nextTarget.key {- return- }-- cancelScheduledTask()- resetRetryWindow()- target = nextTarget- if blockedTargets[nextTarget.key] == .authentication {- blockedTargets.removeValue(forKey: nextTarget.key)- }- }-- private func reconcile(- _ read: AutoResetRead,- now: Date = Date()- ) {- reconcile(- accountIdentity: read.accountIdentity,- availableCount: read.availableCount,- candidates: read.candidates,- now: now- )- }-- private func isCandidateEligible(- _ candidate: AutoResetCandidate,- accountIdentity: String,- now: Date- ) -> Bool {- guard candidate.expirationDate > now else {- return false- }-- let key = AutoResetIdentity.notificationToken(- accountIdentity: accountIdentity,- creditID: candidate.id- )- guard !consumedTargetKeys.contains(key) else {- return false- }- guard let expiredDate = expiredTargetDates[key] else {- return true- }- return candidate.expirationDate > expiredDate- }-- private func makeTarget(- accountIdentity: String,- candidate: AutoResetCandidate- ) -> Target {- Target(- accountIdentity: accountIdentity,- candidate: candidate,- key: AutoResetIdentity.notificationToken(- accountIdentity: accountIdentity,- creditID: candidate.id- )- )- }-- private func thresholdDate(for target: Target) -> Date {- target.candidate.expirationDate- .addingTimeInterval(-settings.leadTime.duration)- }-- @discardableResult- private func startRetryWindowIfNeeded(- for target: Target,- startedAt: Date- ) -> RetryWindow {- if let retryWindow,- retryWindow.targetKey == target.key {- return retryWindow- }-- let retryWindow = RetryWindow(- targetKey: target.key,- deadline: startedAt.addingTimeInterval(Self.retryWindowDuration)- )- self.retryWindow = retryWindow- retryIndex = 0- AppLog.app.notice("自动重置重试窗口已开始")- return retryWindow- }-- private func finishRetryWindow(ifMatching targetKey: String) {- guard retryWindow?.targetKey == targetKey else {- return- }-- retryWindow = nil- retryIndex = 0- AppLog.app.notice("自动重置重试窗口已结束: reason=deadline")- }-- private func resetRetryWindow(ifMatching targetKey: String? = nil) {- if let targetKey,- retryWindow?.targetKey != targetKey {- return+ let plan = record.schedule.plan(expirationDate: target.candidate.expirationDate, leadTime: settings.leadTime.duration, now: dependencies.now())+ records[target.key] = record+ setWakeDate(plan?.wakeDate)+ guard let plan, !isSleeping else { return }+ scheduledDate = plan.evaluationDate+ let generation = generation+ scheduledTask = Task { @MainActor [weak self, sleep = dependencies.sleep] in+ do { try await sleep(plan.evaluationDate) } catch { return }+ guard let self, !Task.isCancelled, generation == self.generation else { return }+ scheduledTask = nil+ scheduledDate = nil+ requestEvaluation(trigger: .auto)}-- retryWindow = nil- retryIndex = 0}- private func finishExpiredTarget(_ expiredTarget: Target) {- expiredTargetDates[expiredTarget.key] = expiredTarget.candidate.expirationDate- clearTarget(ifMatching: expiredTarget.key)- notificationService.notifyAutoResetFailed(- reason: .expired,- dedupToken: expiredTarget.key- )- AppLog.app.error("自动重置失败: reason=expired")- statusViewModel.refreshAfterCurrent(trigger: .autoReset)+ private func updateWakeDate(during evaluation: Evaluation) {+ let finalDate = evaluation.target.candidate.expirationDate.addingTimeInterval(-AutoResetSchedule.finalLeadTime)+ setWakeDate(evaluation.attempt.phase == .final || finalDate <= dependencies.now() ? nil : finalDate)}- private func clearTarget(ifMatching key: String? = nil) {- if let key, target?.key != key {- return- }- cancelScheduledTask()- target = nil- resetRetryWindow()+ private func setWakeDate(_ date: Date?) {+ guard date != wakeDate else { return }+ wakeDate = date+ dependencies.setWakeDate(date)}- private func cancelScheduledTask(clearsWakeSchedule: Bool = true) {+ private func cancelTimer() {scheduledTask?.cancel()scheduledTask = nil- if clearsWakeSchedule {- keepAliveController.setAutoResetWakeDate(nil)- }- }-- private func beginWakeActivityIfNeeded(trigger: LogTrigger) -> Bool {- guard trigger == .auto || trigger == .retry || trigger == .wake else {- return false- }-- let result = wakeActivity.beginPreventingIdleSleep()- guard result == kIOReturnSuccess else {- AppLog.app.error("自动重置短时防睡眠失败: code=\(result)")- return false- }- return true+ scheduledDate = nil}- private func endWakeActivityIfNeeded(_ isActive: Bool) {- guard isActive else {- return- }-- let result = wakeActivity.endPreventingIdleSleep()- if result != kIOReturnSuccess {- AppLog.app.error("自动重置短时防睡眠释放失败: code=\(result)")- }+ private func invalidateEvaluation() {+ generation += 1+ evaluationTask?.cancel()+ // 保留引用直到旧轮收尾, 新触发只排队, 不并行消费同一凭证}private func cancelWork() {- cancelScheduledTask()- resetRetryWindow()- settingsActivationTask?.cancel()- settingsActivationTask = nil- evaluationGeneration += 1- evaluationTask?.cancel()- evaluationTask = nil- pendingEvaluation = false+ cancelTimer()+ setWakeDate(nil)+ activationTask?.cancel()+ activationTask = nil+ pendingTrigger = nil+ invalidateEvaluation()}}diff --git a/CodexBar/Services/CodexStatus/AutoResetSchedule.swift b/CodexBar/Services/CodexStatus/AutoResetSchedule.swiftnew file mode 100644index 0000000..c5b46d7--- /dev/null+++ b/CodexBar/Services/CodexStatus/AutoResetSchedule.swift@@ -0,0 +1,150 @@+import Foundation++/// 同一凭证的尝试预算独立于快照刷新和定时任务生命周期+nonisolated struct AutoResetSchedule {+ enum Phase: Equatable {+ case initial+ case cooldown+ case final+ }++ struct Attempt: Equatable {+ let phase: Phase+ let deadline: Date+ }++ struct Plan: Equatable {+ let evaluationDate: Date+ let wakeDate: Date?+ }++ private var initialStartedAt: Date?+ private var initialAttempts = 0+ private var initialFinished = false+ private var nextAttemptAt: Date?+ private var finalExpirationDate: Date?+ private var finalAttempts = 0+ private var finalFinished = false++ static let finalLeadTime: TimeInterval = 180+ static let cutoffLeadTime: TimeInterval = 60+ private static let initialWindow: TimeInterval = 300+ private static let initialDelays: [TimeInterval] = [15, 30, 60, 120]+ private static let finalDelays: [TimeInterval] = [15, 30]++ static func cooldown(for leadTime: TimeInterval) -> TimeInterval {+ min(900, leadTime / 3)+ }++ static func cutoff(for expirationDate: Date) -> Date {+ expirationDate.addingTimeInterval(-cutoffLeadTime)+ }++ mutating func plan(expirationDate: Date, leadTime: TimeInterval, now: Date) -> Plan? {+ guard now < Self.cutoff(for: expirationDate) else { return nil }+ let threshold = expirationDate.addingTimeInterval(-leadTime)+ let finalDate = expirationDate.addingTimeInterval(-Self.finalLeadTime)+ if finalExpirationDate != expirationDate {+ // 到期时间变化只重排最终机会, 不恢复已耗尽的初始预算+ if let finalExpirationDate, expirationDate < finalExpirationDate {+ self.finalExpirationDate = expirationDate+ } else {+ finalAttempts = 0+ finalFinished = false+ }+ }+ if finalExpirationDate == expirationDate, finalFinished {+ return nil+ }+ if now >= finalDate {+ guard !finalFinished else { return nil }+ let date = finalAttempts == 0 ? now : max(now, nextAttemptAt ?? now)+ guard date < Self.cutoff(for: expirationDate) else { return nil }+ return Plan(evaluationDate: date, wakeDate: finalAttempts == 0 ? finalDate : nil)+ }+ if let start = initialStartedAt, !initialFinished,+ now >= start.addingTimeInterval(Self.initialWindow) {+ finishInitialWindow(now: start.addingTimeInterval(Self.initialWindow), leadTime: leadTime)+ }+ let next = max(threshold, nextAttemptAt ?? threshold)+ let date = min(next, finalDate)+ let wakeDate = initialStartedAt == nil && !initialFinished ? min(threshold, finalDate) : finalDate+ return Plan(evaluationDate: max(now, date), wakeDate: wakeDate)+ }++ mutating func begin(expirationDate: Date, leadTime: TimeInterval, now: Date) -> Attempt? {+ guard let plan = plan(expirationDate: expirationDate, leadTime: leadTime, now: now),+ plan.evaluationDate <= now else { return nil }+ let cutoff = Self.cutoff(for: expirationDate)+ if now >= expirationDate.addingTimeInterval(-Self.finalLeadTime) {+ if finalExpirationDate != expirationDate {+ finalExpirationDate = expirationDate+ finalAttempts = 0+ finalFinished = false+ }+ guard !finalFinished, finalAttempts < 3 else { return nil }+ initialFinished = true+ finalAttempts += 1+ return Attempt(phase: .final, deadline: cutoff)+ }+ if !initialFinished {+ initialStartedAt = initialStartedAt ?? now+ initialAttempts += 1+ return Attempt(+ phase: .initial,+ deadline: min(cutoff, initialStartedAt!.addingTimeInterval(Self.initialWindow))+ )+ }+ return Attempt(phase: .cooldown, deadline: min(cutoff, now.addingTimeInterval(Self.initialWindow)))+ }++ mutating func finish(_ attempt: Attempt, transientFailure: Bool, leadTime: TimeInterval, now: Date) {+ switch attempt.phase {+ case .initial:+ if transientFailure, initialAttempts <= Self.initialDelays.count {+ let next = now.addingTimeInterval(Self.initialDelays[initialAttempts - 1])+ if next < attempt.deadline {+ nextAttemptAt = next+ return+ }+ }+ if transientFailure {+ finishInitialWindow(now: now, leadTime: leadTime)+ } else {+ initialFinished = true+ nextAttemptAt = now.addingTimeInterval(Self.cooldown(for: leadTime))+ }+ case .cooldown:+ nextAttemptAt = now.addingTimeInterval(Self.cooldown(for: leadTime))+ case .final:+ if transientFailure, finalAttempts <= Self.finalDelays.count {+ let next = now.addingTimeInterval(Self.finalDelays[finalAttempts - 1])+ if next < attempt.deadline {+ nextAttemptAt = next+ return+ }+ }+ finalFinished = true+ nextAttemptAt = nil+ }+ }++ /// 普通评估跨过最终复查点时, 该评估承接最终机会, 不额外发起并行请求+ mutating func coverFinalIfNeeded(_ attempt: Attempt, expirationDate: Date, transientFailure: Bool, now: Date) {+ guard attempt.phase != .final,+ now >= expirationDate.addingTimeInterval(-Self.finalLeadTime) else { return }+ finalExpirationDate = expirationDate+ finalAttempts = 1+ initialFinished = true+ let next = now.addingTimeInterval(Self.finalDelays[0])+ let canRetry = transientFailure && next < Self.cutoff(for: expirationDate)+ finalFinished = !canRetry+ nextAttemptAt = canRetry ? next : nil+ }++ private mutating func finishInitialWindow(now: Date, leadTime: TimeInterval) {+ initialFinished = true+ let end = initialStartedAt?.addingTimeInterval(Self.initialWindow) ?? now+ nextAttemptAt = max(end, now).addingTimeInterval(Self.cooldown(for: leadTime))+ }+}diff --git a/CodexBar/Services/CodexStatus/CodexStatusService.swift b/CodexBar/Services/CodexStatus/CodexStatusService.swiftindex c266516..dbb5163 100644--- a/CodexBar/Services/CodexStatus/CodexStatusService.swift+++ b/CodexBar/Services/CodexStatus/CodexStatusService.swift@@ -197,9 +197,11 @@ actor CodexStatusService {}/// 自动重置前必须绕过补充数据缓存读取一份新凭证明细- func readCreditsForAutoReset() throws -> AutoResetRead {- try withAutoResetConnection { connection in- try readCreditsForAutoReset(using: connection)+ func readCreditsForAutoReset(budget: AppServerRequestBudget) throws -> AutoResetRead {+ try AppServerRequestBudget.$current.withValue(budget) {+ try withAutoResetConnection { connection in+ try readCreditsForAutoReset(using: connection)+ }}}@@ -207,7 +209,20 @@ actor CodexStatusService {func consumeResetCredit(id creditID: String,idempotencyKey: String,- expectedAccountIdentity: String+ expectedAccountIdentity: String,+ expirationDate: Date,+ budget: AppServerRequestBudget+ ) throws -> ResetCreditConsumeResult {+ try AppServerRequestBudget.$current.withValue(budget) {+ try consumeResetCreditWithinBudget(id: creditID, idempotencyKey: idempotencyKey, expectedAccountIdentity: expectedAccountIdentity, expirationDate: expirationDate)+ }+ }++ private func consumeResetCreditWithinBudget(+ id creditID: String,+ idempotencyKey: String,+ expectedAccountIdentity: String,+ expirationDate: Date) throws -> ResetCreditConsumeResult {let response: ResetCreditConsumeResponse = try withAutoResetConnection { connection inlet accountResponse = try connection.session.request(@@ -223,6 +238,11 @@ actor CodexStatusService {}connection.accountResponse = accountResponse+ // 每次重发前重查, 排队和认证刷新都可能跨过截止时间+ try AppServerRequestBudget.checkCurrent()+ guard Date() < AutoResetSchedule.cutoff(for: expirationDate) else {+ throw AutoResetServiceError.deadlineReached+ }return try connection.session.request("account/rateLimitResetCredit/consume",params: [@@ -235,7 +255,7 @@ actor CodexStatusService {// 消费结果已经确定时刷新失败不能覆盖结果// 控制器仍会触发完整额度刷新, 这里先满足协议要求并尽快取得剩余次数- let refreshedRead = try? readCreditsForAutoReset()+ let refreshedRead = try? withAutoResetConnection { try readCreditsForAutoReset(using: $0) }return ResetCreditConsumeResult(outcome: response.outcome,refreshedRead: refreshedRead@@ -308,6 +328,7 @@ actor CodexStatusService {var canRebuild = truewhile true {+ try AppServerRequestBudget.checkCurrent()let activeConnection = try readyConnection()do {@@ -330,6 +351,7 @@ actor CodexStatusService {do {return try operation(connection)} catch let error as CodexStatusError where error.isAuthenticationRequired {+ try AppServerRequestBudget.checkCurrent()do {try Self.refreshAccount(using: connection)} catch FetchFailure.notLoggedIn {diff --git a/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift b/CodexBar/Services/CodexStatus/CodexStatusViewModel.swiftindex 9a42e48..1dff450 100644--- a/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift+++ b/CodexBar/Services/CodexStatus/CodexStatusViewModel.swift@@ -188,7 +188,7 @@ final class CodexStatusViewModel: ObservableObject {)}- /// 自动消费完成后不能因为普通刷新正在运行而丢掉最终对账+ /// 自动消费完成后不能因为普通刷新正在运行而丢掉最终核对func refreshAfterCurrent(trigger: LogTrigger) {guard isRefreshing || isReconnecting else {refresh(trigger: trigger)diff --git a/CodexBar/Services/KeepAlive/HelperStatusMonitor.swift b/CodexBar/Services/KeepAlive/HelperStatusMonitor.swiftindex e305fe5..e6ca15d 100644--- a/CodexBar/Services/KeepAlive/HelperStatusMonitor.swift+++ b/CodexBar/Services/KeepAlive/HelperStatusMonitor.swift@@ -95,7 +95,7 @@ final class HelperStatusMonitor {case let .updateReset(exitCode):guard exitCode == 0 else {AppLog.keepAlive.error(- "Helper 更新后的睡眠重置失败: exit=\(exitCode)"+ "Helper 更新后睡眠状态检查失败: exit=\(exitCode)")return false}@@ -105,7 +105,7 @@ final class HelperStatusMonitor {case .timedOut:let wait = LogDuration.seconds(timeout)AppLog.keepAlive.error(- "Helper 更新后的睡眠重置超时: timeout=\(wait, privacy: .public)"+ "Helper 更新后睡眠状态检查超时: timeout=\(wait, privacy: .public)")onTimeout()case .status, .wakeSchedule, .invalidResponse, .cancelled:diff --git a/CodexBar/Services/KeepAlive/KeepAliveController.swift b/CodexBar/Services/KeepAlive/KeepAliveController.swiftindex 4b86d7a..bdd8003 100644--- a/CodexBar/Services/KeepAlive/KeepAliveController.swift+++ b/CodexBar/Services/KeepAlive/KeepAliveController.swift@@ -631,7 +631,7 @@ final class KeepAliveController: ObservableObject {} else if helperStatus == .enabled {helperWasUpdated = await completeHelperUpdate(updateIdentifier)} else {- // 从 enabled 更新后若需要系统批准, 一次性重置会在批准后继续+ // 从 enabled 更新后若需要系统批准, 睡眠状态核对会在批准后继续helperWasUpdated = true}}diff --git a/CodexBarHelper/HelperRuntime.swift b/CodexBarHelper/HelperRuntime.swiftindex a3d8ad2..2951905 100644--- a/CodexBarHelper/HelperRuntime.swift+++ b/CodexBarHelper/HelperRuntime.swift@@ -139,7 +139,8 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable}private let queue = DispatchQueue(label: CodexBarHelperIPC.machServiceName + ".state")- private let ownershipStore = OwnershipStore(url: CodexBarHelperStorage.ownershipURL)+ private let ownershipStore: any OwnershipStoring+ private let sleepOperations: HelperSleepOperationsprivate var ownership = SleepOwnership.idleprivate var transactionID = UUID()private var lastCompletedUpdateIdentifier: String?@@ -154,6 +155,12 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendableprivate var signalSources = [DispatchSourceSignal]()private var listener: NSXPCListener?+ init(ownershipStore: (any OwnershipStoring)? = nil, sleepOperations: HelperSleepOperations = .system) {+ self.ownershipStore = ownershipStore ?? OwnershipStore(url: CodexBarHelperStorage.ownershipURL)+ self.sleepOperations = sleepOperations+ super.init()+ }+func run() {guard geteuid() == 0 else {helperLog.error("Helper 启动失败: reason=notRoot")@@ -281,16 +288,17 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendablereturn}- let result = setAndVerifySleepDisabled(false)- guard result.exitCode == 0 else {- reply(result.exitCode)+ let exitCode = reconcileSleepAfterUpdate()+ guard exitCode == 0 else {+ reply(exitCode)return}let previousUpdateIdentifier = lastCompletedUpdateIdentifierlastCompletedUpdateIdentifier = updateIdentifierdo {- try persistOwnership(.idle)+ // 更新完成不代表系统必须允许睡眠, 有效租约和外部设置仍然保留+ try persistOwnership(ownership)} catch {lastCompletedUpdateIdentifier = previousUpdateIdentifierlogOwnershipWriteFailure(error)@@ -298,11 +306,23 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendablereturn}- helperLog.notice("Helper 更新后睡眠状态已重置")+ helperLog.notice("Helper 更新后已完成睡眠状态检查")reply(0)}}+ private func reconcileSleepAfterUpdate() -> Int32 {+ if ownership.needsRestore || activeClientCount > 0 {+ return reconcileReleasedSleep(source: currentSource(), trigger: .appRequest).exitCode+ }+ let current = readCurrentSleepDisabled()+ guard current.result.exitCode == 0, current.value != nil else {+ logPmsetReadFailure(current.result)+ return normalizedFailureCode(current.result.exitCode)+ }+ return 0+ }+fileprivate func setAutoResetWakeSchedule(_ unixTimestamp: TimeInterval,for identifier: UUID,@@ -623,7 +643,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendableprivate func setAndVerifySleepDisabled(_ disabled: Bool) -> (exitCode: Int32, value: Bool?) {- let writeResult = PmsetRunner.setSleepDisabled(disabled)+ let writeResult = sleepOperations.write(disabled)guard writeResult.exitCode == 0 else {let details = LogFields.joined("target=\(disabled ? 1 : 0)",@@ -651,7 +671,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable}private func readCurrentSleepDisabled() -> (result: PmsetResult, value: Bool?) {- let current = PmsetRunner.currentSleepDisabled()+ let current = sleepOperations.read()if current.result.exitCode == 0, let value = current.value {lastKnownSleepDisabled = value}@@ -725,7 +745,7 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable// MARK: - 异常恢复- private func recoverOwnershipAtStartup() {+ func recoverOwnershipAtStartup() {let state = ownershipStore.ownershipRecordState()switch state {case .absent:diff --git a/CodexBarHelper/OwnershipStore.swift b/CodexBarHelper/OwnershipStore.swiftindex aa299d9..8aa415d 100644--- a/CodexBarHelper/OwnershipStore.swift+++ b/CodexBarHelper/OwnershipStore.swift@@ -36,7 +36,14 @@ enum OwnershipRecordState {case unreadable(Error)}-struct OwnershipStore {+protocol OwnershipStoring {+ var url: URL { get }+ func ensureOwnershipDirectory() throws+ func writeOwnershipDataDurably(_ data: Data) throws+ func ownershipRecordState() -> OwnershipRecordState+}++struct OwnershipStore: OwnershipStoring {let url: URLfunc ensureOwnershipDirectory() throws {diff --git a/CodexBarHelper/Pmset.swift b/CodexBarHelper/Pmset.swiftindex a8cc9c5..f3cb666 100644--- a/CodexBarHelper/Pmset.swift+++ b/CodexBarHelper/Pmset.swift@@ -7,6 +7,15 @@ struct PmsetResult {let output: String}+struct HelperSleepOperations {+ var read: () -> (result: PmsetResult, value: Bool?)+ var write: (Bool) -> PmsetResult++ static var system: Self {+ Self(read: PmsetRunner.currentSleepDisabled, write: PmsetRunner.setSleepDisabled)+ }+}+// MARK: - pmset 调用enum PmsetRunner {diff --git a/CodexBarHelperTests/HelperUpdateTests.swift b/CodexBarHelperTests/HelperUpdateTests.swiftnew file mode 100644index 0000000..4c093bf--- /dev/null+++ b/CodexBarHelperTests/HelperUpdateTests.swift@@ -0,0 +1,167 @@+import Foundation+import Synchronization+import Testing++@Suite(.timeLimit(.minutes(1)))+struct HelperUpdateTests {+ @Test func updatePreservesExternalSleepSetting() async throws {+ let fixture = try Fixture(disabled: true)+ #expect(await fixture.update() == 0)+ #expect(fixture.system.values.withLock { $0.writes } == [])+ #expect(fixture.store.record()?.state == .idle)+ #expect(fixture.store.record()?.identifier == fixture.updateID)+ }++ @Test func updateKeepsLiveLeaseAndReleaseStillRestoresSleep() async throws {+ let fixture = try Fixture(disabled: false)+ #expect(await fixture.request(true, generation: 1) == 0)+ #expect(fixture.system.values.withLock { $0.disabled })+ #expect(await fixture.update() == 0)+ #expect(fixture.store.record()?.state == .owned)+ #expect(fixture.system.values.withLock { $0.writes } == [true])+ #expect(await fixture.request(false, generation: 2) == 0)+ #expect(fixture.system.values.withLock { $0.writes } == [true, false])+ #expect(fixture.store.record()?.state == .idle)+ }++ @Test func updateRetriesUnfinishedOwnedRecovery() async throws {+ let fixture = try Fixture(disabled: true, ownership: .owned, failWrite: true)+ #expect(fixture.store.record()?.state == .restoring)+ #expect(await fixture.update() != 0)+ #expect(fixture.store.record()?.identifier == nil)+ fixture.system.values.withLock { $0.failWrite = false }+ #expect(await fixture.update() == 0)+ #expect(!fixture.system.values.withLock { $0.disabled })+ #expect(fixture.store.record()?.state == .idle)+ #expect(fixture.store.record()?.identifier == fixture.updateID)+ }++ @Test func failedPersistenceDoesNotConsumeUpdateIdentifier() async throws {+ let fixture = try Fixture(disabled: true)+ fixture.store.values.withLock { $0.failWrite = true }+ #expect(await fixture.update() != 0)+ #expect(fixture.store.record()?.identifier == nil)+ fixture.store.values.withLock { $0.failWrite = false }+ #expect(await fixture.update() == 0)+ let writes = fixture.store.values.withLock { $0.writes }+ #expect(await fixture.update() == 0)+ #expect(fixture.store.values.withLock { $0.writes } == writes)+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)+ }++ @Test func failedReadCannotCompleteUpdate() async throws {+ let fixture = try Fixture(disabled: true)+ fixture.system.values.withLock { $0.failRead = true }+ #expect(await fixture.update() != 0)+ #expect(fixture.store.record()?.identifier == nil)+ fixture.system.values.withLock { $0.failRead = false }+ #expect(await fixture.update() == 0)+ #expect(fixture.system.values.withLock { $0.writes }.isEmpty)+ }+}++private struct Fixture {+ let store: MemoryOwnership+ let system: FakeSleepSystem+ let runtime: HelperRuntime+ let session: any CodexBarHelperProtocol+ let connection: TestConnection+ let clientID = UUID().uuidString+ let updateID = String(repeating: "a", count: 64)++ init(disabled: Bool, ownership: SleepOwnership = .idle, failWrite: Bool = false) throws {+ store = try MemoryOwnership(state: ownership)+ system = FakeSleepSystem(disabled: disabled, failWrite: failWrite)+ runtime = HelperRuntime(ownershipStore: store, sleepOperations: system.operations)+ runtime.recoverOwnershipAtStartup()+ connection = TestConnection()+ precondition(runtime.listener(NSXPCListener.anonymous(), shouldAcceptNewConnection: connection))+ session = try #require(connection.exportedObject as? any CodexBarHelperProtocol)+ }++ func update() async -> Int32 {+ await withCheckedContinuation { continuation in+ session.resetSleepAfterUpdate(updateID) { continuation.resume(returning: $0) }+ }+ }++ func request(_ requested: Bool, generation: UInt64) async -> Int32 {+ await withCheckedContinuation { continuation in+ session.setSleepPreventionRequested(requested, clientSessionID: clientID, generation: generation) { code, _, _ in+ continuation.resume(returning: code)+ }+ }+ }+}++private final class TestConnection: NSXPCConnection, @unchecked Sendable {+ override func resume() {}+}++private final class MemoryOwnership: OwnershipStoring, Sendable {+ struct State: Sendable {+ var data: Data+ var failWrite = false+ var writes = 0+ }++ let url = URL(fileURLWithPath: "/unused-helper-test-state")+ let values: Mutex<State>++ init(state: SleepOwnership) throws {+ let record = SleepOwnershipRecord(schema: 1, state: state, transaction: UUID(), identifier: nil, updated: Date())+ let encoder = JSONEncoder()+ encoder.dateEncodingStrategy = .iso8601+ values = try Mutex(State(data: encoder.encode(record)))+ }++ func ensureOwnershipDirectory() throws {}+ func writeOwnershipDataDurably(_ data: Data) throws {+ try values.withLock {+ if $0.failWrite {+ throw CocoaError(.fileWriteUnknown)+ }+ $0.data = data+ $0.writes += 1+ }+ }++ func record() -> SleepOwnershipRecord? {+ let decoder = JSONDecoder()+ decoder.dateDecodingStrategy = .iso8601+ return try? decoder.decode(SleepOwnershipRecord.self, from: values.withLock { $0.data })+ }++ func ownershipRecordState() -> OwnershipRecordState {+ record().map(OwnershipRecordState.present) ?? .absent+ }+}++private final class FakeSleepSystem: Sendable {+ struct State: Sendable {+ var disabled: Bool+ var failWrite: Bool+ var failRead = false+ var writes: [Bool] = []+ }++ let values: Mutex<State>+ init(disabled: Bool, failWrite: Bool) {+ values = Mutex(State(disabled: disabled, failWrite: failWrite))+ }++ var operations: HelperSleepOperations {+ HelperSleepOperations(read: { [self] in+ values.withLock { (PmsetResult(exitCode: $0.failRead ? -1 : 0, output: ""), $0.failRead ? nil : $0.disabled) }+ }, write: { [self] disabled in+ values.withLock {+ if $0.failWrite {+ return PmsetResult(exitCode: -1, output: "test failure")+ }+ $0.disabled = disabled+ $0.writes.append(disabled)+ return PmsetResult(exitCode: 0, output: "")+ }+ })+ }+}diff --git a/CodexBarTests/ActivitySchedulingTests.swift b/CodexBarTests/ActivitySchedulingTests.swiftindex 610ec86..174e7b3 100644--- a/CodexBarTests/ActivitySchedulingTests.swift+++ b/CodexBarTests/ActivitySchedulingTests.swift@@ -263,7 +263,7 @@ struct ActivitySchedulingTests {try peer.reply(to: request, result: ["data": ["a-missing", "thread"]])onDiscovery()}- // 强制对账重新尝试失败线程, 服务端恢复后无需重连即可加入+ // 强制核对重新尝试失败线程, 服务端恢复后无需重连即可加入let discovery = try peer.readMessage()#expect(discovery["method"] as? String == "thread/loaded/list")try peer.reply(to: discovery, result: ["data": ["a-missing", "thread"]])diff --git a/CodexBarTests/AppServerRequestBudgetTests.swift b/CodexBarTests/AppServerRequestBudgetTests.swiftnew file mode 100644index 0000000..c11e060--- /dev/null+++ b/CodexBarTests/AppServerRequestBudgetTests.swift@@ -0,0 +1,95 @@+import Darwin+import Foundation+import Testing++@Suite(.timeLimit(.minutes(1)))+struct AppServerRequestBudgetTests {+ @Test func expiredBudgetNeverSendsRequest() async throws {+ let server = try SharedServerFixture { peer in+ var byte: UInt8 = 0+ #expect(Darwin.read(peer.descriptor, &byte, 1) == 0)+ }+ defer { server.close() }+ let socketURL = server.url+ try await Task.detached {+ let session = try AccountSession(socketURL: socketURL, logStorage: nil)+ defer { session.close() }+ let budget = AppServerRequestBudget(deadline: Date().addingTimeInterval(-1))+ #expect(throws: CodexStatusError.self) {+ try AppServerRequestBudget.$current.withValue(budget) {+ let _: [String: String] = try session.request("account/read", as: [String: String].self)+ }+ }+ }.value+ try server.finish()+ }++ @Test func requestBudgetBoundsPartialFrameRead() async throws {+ let release = DispatchSemaphore(value: 0)+ defer { release.signal() }+ let server = try SharedServerFixture { peer in+ _ = try peer.readMessage()+ var header: [UInt8] = [0x81, 100, 123]+ #expect(Darwin.write(peer.descriptor, &header, header.count) == header.count)+ #expect(release.wait(timeout: .now() + 3) == .success)+ }+ defer { server.close() }+ let socketURL = server.url+ try await Task.detached {+ let session = try AccountSession(socketURL: socketURL, logStorage: nil)+ defer { session.close() }+ let started = ContinuousClock.now+ let budget = AppServerRequestBudget(deadline: Date().addingTimeInterval(0.1))+ #expect(throws: CodexStatusError.self) {+ try AppServerRequestBudget.$current.withValue(budget) {+ let _: [String: String] = try session.request("account/read", as: [String: String].self)+ }+ }+ #expect(started.duration(to: .now) < .seconds(1))+ #expect(!session.isOpen)+ }.value+ release.signal()+ try server.finish()+ }++ @Test func constrainedBudgetCannotExtendMonotonicDeadline() {+ let original = AppServerRequestBudget(deadline: Date().addingTimeInterval(60))+ let movedClock = Date().addingTimeInterval(-3600)+ let constrained = original.constrained(to: original.wallDeadline, now: movedClock)+ #expect(constrained.deadline <= original.deadline)+ #expect(constrained.wallDeadline == original.wallDeadline)+ }++ @Test func expiredCreditIsRejectedBeforeConsumeEvenWithRemainingRequestBudget() async throws {+ let server = try SharedServerFixture { peer in+ let initialize = try peer.readMessage()+ try peer.reply(to: initialize, result: ["userAgent": "codex/0.157.0"])+ #expect(try peer.readMessage()["method"] as? String == "initialized")+ for _ in 0 ..< 2 {+ let account = try peer.readMessage()+ #expect(account["method"] as? String == "account/read")+ try peer.reply(to: account, result: ["account": ["type": "chatgpt", "email": "[email protected]", "planType": "plus"]])+ }+ // 请求预算仍有余量, 但凭证已进入安全截止区间+ var byte: UInt8 = 0+ #expect(Darwin.read(peer.descriptor, &byte, 1) == 0)+ }+ defer { server.close() }+ let socketURL = server.url+ try await Task.detached {+ let service = CodexStatusService(socketURL: socketURL)+ do {+ _ = try await service.consumeResetCredit(+ id: "test-credit", idempotencyKey: "test-key",+ expectedAccountIdentity: "chatgpt\u{0}[email protected]",+ expirationDate: Date().addingTimeInterval(30),+ budget: AppServerRequestBudget(deadline: Date().addingTimeInterval(60))+ )+ Issue.record("Credit past safety cutoff was consumed")+ } catch AutoResetServiceError.deadlineReached {+ // 预期截止, actor 释放后关闭测试连接+ }+ }.value+ try server.finish()+ }+}diff --git a/CodexBarTests/AutoResetControllerTests.swift b/CodexBarTests/AutoResetControllerTests.swiftnew file mode 100644index 0000000..8341841--- /dev/null+++ b/CodexBarTests/AutoResetControllerTests.swift@@ -0,0 +1,313 @@+import Combine+import Foundation+import IOKit+import Testing++@Suite(.timeLimit(.minutes(1)))+struct AutoResetControllerTests {+ @Test func repeatedSnapshotsCannotRestartExhaustedWindow() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ fixture.state.error = CodexStatusError.serverTimeout+ fixture.controller.start()+ // 首次读取尚无目标, 用快照发现凭证后再计入业务尝试+ try fixture.snapshots.send(fixture.snapshot())+ for (index, offset) in [0.0, 15, 45, 105, 225].enumerated() {+ fixture.clock.advance(to: fixture.start.addingTimeInterval(offset))+ try await eventually { fixture.controller.scheduledDate != nil && fixture.state.readCount >= index + 1 }+ for _ in 0 ..< 10 {+ try fixture.snapshots.send(fixture.snapshot())+ }+ if index < 4 {+ #expect(fixture.controller.scheduledDate == fixture.start.addingTimeInterval([15, 45, 105, 225][index]))+ }+ }+ #expect(fixture.controller.scheduledDate == fixture.start.addingTimeInterval(600))+ #expect(fixture.controller.wakeDate == fixture.expiration.addingTimeInterval(-180))+ #expect(fixture.state.consumeCount == 0)+ #expect(fixture.state.activeAssertions.isEmpty)+ }++ @Test func disableAndReenableWaitsForOldCleanupAndUsesFreshAssertion() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ let oldRead = ResetGate<AutoResetRead>()+ let newConsume = ResetGate<ResetCreditConsumeResult>()+ fixture.state.readOverride = { await oldRead.wait() }+ fixture.controller.start()+ try await eventually { fixture.state.readCount == 1 }+ #expect(fixture.state.activeAssertions.count == 1)+ fixture.settings.setEnabled(false)+ fixture.state.readOverride = nil+ fixture.state.consumeOverride = { await newConsume.wait() }+ fixture.settings.setEnabled(true)+ await settle()+ #expect(fixture.state.readCount == 1)+ oldRead.release(fixture.state.read)+ try await eventually { fixture.state.consumeCount == 1 }+ #expect(fixture.state.createdAssertions == 2)+ #expect(fixture.state.activeAssertions == [2])+ newConsume.release(ResetCreditConsumeResult(outcome: .nothingToReset, refreshedRead: fixture.state.read))+ try await eventually { fixture.state.activeAssertions.isEmpty }+ #expect(fixture.state.releasedAssertions == [1, 2])+ }++ @Test func confirmedSuccessAfterDisableDoesNotRecreateSchedule() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ let consume = ResetGate<ResetCreditConsumeResult>()+ fixture.state.consumeOverride = { await consume.wait() }+ fixture.controller.start()+ try await eventually { fixture.state.consumeCount == 1 }+ fixture.settings.setEnabled(false)+ consume.release(ResetCreditConsumeResult(outcome: .reset, refreshedRead: fixture.state.read))+ try await eventually { fixture.state.activeAssertions.isEmpty }+ #expect(fixture.state.successes == 1)+ #expect(fixture.controller.scheduledDate == nil)+ #expect(fixture.controller.wakeDate == nil)+ fixture.settings.setEnabled(true)+ try await eventually { fixture.state.readCount >= 2 && fixture.state.activeAssertions.isEmpty }+ #expect(fixture.state.consumeCount == 1)+ }++ @Test func ordinaryCheckKeepsFinalWakeAndSleepingDoesNotCatchUp() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ fixture.controller.start()+ try await eventually { fixture.controller.scheduledDate != nil }+ #expect(fixture.controller.scheduledDate == fixture.start.addingTimeInterval(300))+ #expect(fixture.controller.wakeDate == fixture.start.addingTimeInterval(720))+ fixture.controller.handleSleep()+ fixture.clock.advance(to: fixture.start.addingTimeInterval(730))+ await settle()+ #expect(fixture.state.consumeCount == 1)+ #expect(fixture.controller.scheduledDate == nil)+ fixture.controller.handleWake()+ try await eventually { fixture.state.consumeCount == 2 && fixture.state.activeAssertions.isEmpty }+ #expect(fixture.controller.scheduledDate == nil)+ #expect(fixture.controller.wakeDate == nil)+ for _ in 0 ..< 10 {+ try fixture.snapshots.send(fixture.snapshot())+ }+ await settle()+ #expect(fixture.state.consumeCount == 2)+ }++ @Test func lateStartWithinSafetyMarginNeverConsumes() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ fixture.clock.advance(to: fixture.expiration.addingTimeInterval(-50))+ fixture.controller.start()+ try await eventually { fixture.state.readCount == 1 && fixture.state.activeAssertions.isEmpty }+ #expect(fixture.state.consumeCount == 0)+ #expect(fixture.controller.scheduledDate == nil)+ }++ @Test func cancelledReadAcrossFinalPointDoesNotUseFinalOpportunity() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ let gate = ResetGate<AutoResetRead>()+ fixture.state.readOverride = { await gate.wait() }+ try fixture.snapshots.send(fixture.snapshot())+ fixture.controller.start()+ try await eventually { fixture.state.readCount == 1 }+ fixture.controller.handleSleep()+ fixture.clock.advance(to: fixture.start.addingTimeInterval(730))+ fixture.state.readOverride = nil+ fixture.controller.handleWake()+ gate.release(fixture.state.read)+ try await eventually { fixture.state.consumeCount == 1 && fixture.state.activeAssertions.isEmpty }+ #expect(fixture.controller.scheduledDate == nil)+ }++ @Test func terminationPreparationFreezesAndCancellationResumes() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ fixture.controller.start()+ try await eventually { fixture.controller.scheduledDate != nil }+ fixture.controller.prepareForTermination()+ fixture.clock.advance(to: fixture.start.addingTimeInterval(400))+ try fixture.snapshots.send(fixture.snapshot())+ await settle()+ #expect(fixture.state.consumeCount == 1)+ #expect(fixture.controller.wakeDate == nil)+ fixture.controller.resumeAfterTerminationCancellation()+ try await eventually { fixture.state.consumeCount == 2 && fixture.state.activeAssertions.isEmpty }+ }++ @Test func changedAccountRejectsLateOldRead() async throws {+ let fixture = try ResetFixture()+ defer { fixture.stop() }+ let gate = ResetGate<AutoResetRead>()+ let old = fixture.state.read+ try fixture.snapshots.send(fixture.snapshot())+ fixture.state.readOverride = { await gate.wait() }+ fixture.controller.start()+ try await eventually { fixture.state.readCount == 1 }+ fixture.state.account = CodexAccount(type: "chatgpt", email: "[email protected]", planType: "plus")+ fixture.state.readOverride = nil+ try fixture.snapshots.send(fixture.snapshot())+ gate.release(old)+ try await eventually { fixture.state.consumeCount == 1 && fixture.state.activeAssertions.isEmpty }+ #expect(fixture.state.consumedAccounts == [AutoResetIdentity.accountIdentity(for: fixture.state.account)])+ }+}++private func eventually(_ predicate: () -> Bool) async throws {+ let deadline = ContinuousClock.now.advanced(by: .seconds(3))+ while !predicate(), ContinuousClock.now < deadline {+ try await Task.sleep(for: .milliseconds(1))+ }+ try #require(predicate())+}++private func settle() async {+ for _ in 0 ..< 30 {+ await Task.yield()+ }+}++private final class ResetGate<Value: Sendable> {+ private var waiter: CheckedContinuation<Value, Never>?+ func wait() async -> Value {+ await withCheckedContinuation { waiter = $0 }+ }++ func release(_ value: Value) {+ waiter?.resume(returning: value)+ waiter = nil+ }+}++private final class ResetClock {+ var now: Date+ private var waiters: [UUID: (Date, CheckedContinuation<Void, any Error>)] = [:]+ init(now: Date) {+ self.now = now+ }++ func sleep(until date: Date) async throws {+ if date <= now {+ try Task.checkCancellation()+ return+ }+ let id = UUID()+ try await withTaskCancellationHandler {+ try Task.checkCancellation()+ try await withCheckedThrowingContinuation { waiters[id] = (date, $0) }+ } onCancel: {+ Task { @MainActor [weak self] in self?.waiters.removeValue(forKey: id)?.1.resume(throwing: CancellationError()) }+ }+ }++ func advance(to date: Date) {+ now = date+ for (id, entry) in waiters where entry.0 <= date {+ waiters.removeValue(forKey: id)?.1.resume()+ }+ }+}++private final class ResetState {+ var account = CodexAccount(type: "chatgpt", email: "[email protected]", planType: "plus")+ let candidate: AutoResetCandidate+ var read: AutoResetRead {+ AutoResetRead(accountIdentity: AutoResetIdentity.accountIdentity(for: account), availableCount: 1, candidates: [candidate])+ }++ var error: (any Error)?+ var readOverride: (() async throws -> AutoResetRead)?+ var consumeOverride: (() async throws -> ResetCreditConsumeResult)?+ var readCount = 0+ var consumeCount = 0+ var consumedAccounts: [String] = []+ var successes = 0+ var createdAssertions = 0+ var activeAssertions: Set<Int> = []+ var releasedAssertions: [Int] = []+ init(expiration: Date) {+ candidate = AutoResetCandidate(id: "test-credit", expirationDate: expiration)+ }+}++private final class ResetAssertion: AutoResetWakeActivity {+ let id: Int+ let state: ResetState+ init(state: ResetState) {+ self.state = state+ state.createdAssertions += 1+ id = state.createdAssertions+ }++ func beginPreventingIdleSleep() -> IOReturn {+ state.activeAssertions.insert(id)+ return kIOReturnSuccess+ }++ func endPreventingIdleSleep() -> IOReturn {+ state.activeAssertions.remove(id)+ state.releasedAssertions.append(id)+ return kIOReturnSuccess+ }+}++private final class ResetFixture {+ let preferences: TestPreferences+ let settings: AutoResetSettings+ let controller: AutoResetController+ let snapshots = CurrentValueSubject<CodexQuotaSnapshot?, Never>(nil)+ let start = Date(timeIntervalSince1970: 1800000000)+ let clock: ResetClock+ let state: ResetState+ var expiration: Date {+ state.candidate.expirationDate+ }++ init() throws {+ preferences = try TestPreferences()+ settings = AutoResetSettings(defaults: preferences.defaults)+ settings.setLeadTime(.fifteenMinutes)+ settings.setEnabled(true)+ clock = ResetClock(now: start)+ state = ResetState(expiration: start.addingTimeInterval(900))+ let state = state+ let clock = clock+ controller = AutoResetController(settings: settings, snapshots: snapshots.eraseToAnyPublisher(), dependencies: .init(+ read: { _ in+ state.readCount += 1+ if let handler = state.readOverride {+ return try await handler()+ }+ if let error = state.error {+ throw error+ }+ return state.read+ },+ consume: { _, account, _ in+ state.consumeCount += 1+ state.consumedAccounts.append(account)+ if let handler = state.consumeOverride {+ return try await handler()+ }+ return ResetCreditConsumeResult(outcome: .nothingToReset, refreshedRead: state.read)+ },+ setRequested: { _ in }, setWakeDate: { _ in },+ succeeded: { _, _ in state.successes += 1 }, failed: { _, _ in }, refresh: {},+ makeWakeActivity: { ResetAssertion(state: state) }, now: { clock.now }, sleep: { try await clock.sleep(until: $0) }+ ))+ }++ func snapshot() throws -> CodexQuotaSnapshot {+ let response = try TestFixtures.decode(AccountRateLimitsResponse.self, """+ {"rateLimits":{},"rateLimitResetCredits":{"availableCount":1,"credits":[+ {"id":"test-credit","status":"available","resetType":"codexRateLimits","expiresAt":\(Int(expiration.timeIntervalSince1970))}+ ]}}+ """)+ return try CodexQuotaSnapshot(accountResponse: AccountReadResponse(account: state.account), rateLimitsResponse: response)+ }++ func stop() {+ controller.stop()+ preferences.remove()+ }+}diff --git a/CodexBarTests/AutoResetScheduleTests.swift b/CodexBarTests/AutoResetScheduleTests.swiftnew file mode 100644index 0000000..c338890--- /dev/null+++ b/CodexBarTests/AutoResetScheduleTests.swift@@ -0,0 +1,135 @@+import Foundation+import Testing++struct AutoResetScheduleTests {+ private let start = Date(timeIntervalSince1970: 1800000000)++ @Test(arguments: [900.0, 1800, 21600])+ func initialBudgetSurvivesRepeatedRefreshesAndEntersAdaptiveCooldown(_ lead: Double) throws {+ let expiration = start.addingTimeInterval(lead)+ var schedule = AutoResetSchedule()+ for (index, offset) in [0.0, 15, 45, 105, 225].enumerated() {+ let now = start.addingTimeInterval(offset)+ let observed1 = schedule.begin(expirationDate: expiration, leadTime: lead, now: now)+ let attempt = try #require(observed1)+ #expect(attempt.phase == .initial)+ schedule.finish(attempt, transientFailure: true, leadTime: lead, now: now)+ if index < 4 {+ let expected = start.addingTimeInterval([15, 45, 105, 225][index])+ for _ in 0 ..< 20 {+ let observed2 = schedule.plan(expirationDate: expiration, leadTime: lead, now: now)+ #expect(observed2?.evaluationDate == expected)+ }+ }+ }+ let cooldownEnd = start.addingTimeInterval(300 + min(900, lead / 3))+ let observed3 = schedule.plan(expirationDate: expiration, leadTime: lead, now: start.addingTimeInterval(300))+ #expect(observed3?.evaluationDate == cooldownEnd)+ let observed4 = schedule.begin(expirationDate: expiration, leadTime: lead, now: cooldownEnd.addingTimeInterval(-1))+ #expect(observed4 == nil)+ let observed5 = schedule.begin(expirationDate: expiration, leadTime: lead, now: cooldownEnd)+ let attempt = try #require(observed5)+ #expect(attempt.phase == .cooldown)+ schedule.finish(attempt, transientFailure: true, leadTime: lead, now: cooldownEnd)+ let observed6 = schedule.plan(expirationDate: expiration, leadTime: lead, now: cooldownEnd)+ #expect(observed6?.wakeDate == expiration.addingTimeInterval(-180))+ }++ @Test func nothingToResetWaitsWithoutOpeningFaultWindowAgain() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(900)+ let observed7 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start)+ let attempt = try #require(observed7)+ schedule.finish(attempt, transientFailure: false, leadTime: 900, now: start)+ let observed8 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start)+ #expect(observed8?.evaluationDate == start.addingTimeInterval(300))+ let observed9 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(300))+ let next = try #require(observed9)+ #expect(next.phase == .cooldown)+ }++ @Test func finalRoundOverridesCooldownAndStopsBeforeExpiration() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(900)+ let observed10 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start)+ let initial = try #require(observed10)+ schedule.finish(initial, transientFailure: false, leadTime: 900, now: start)+ let observed11 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(600))+ let ordinary = try #require(observed11)+ schedule.finish(ordinary, transientFailure: true, leadTime: 900, now: start.addingTimeInterval(600))+ let observed12 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(600))+ #expect(observed12?.evaluationDate == expiration.addingTimeInterval(-180))+ for offset in [720.0, 735, 765] {+ let now = start.addingTimeInterval(offset)+ let observed13 = schedule.begin(expirationDate: expiration, leadTime: 900, now: now)+ let attempt = try #require(observed13)+ #expect(attempt.phase == .final)+ #expect(attempt.deadline == expiration.addingTimeInterval(-60))+ schedule.finish(attempt, transientFailure: true, leadTime: 900, now: now)+ }+ let observed14 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(800))+ #expect(observed14 == nil)+ let observed15 = schedule.begin(expirationDate: expiration, leadTime: 900, now: expiration.addingTimeInterval(-60))+ #expect(observed15 == nil)+ }++ @Test func lateLaunchUsesOnlyRemainingFinalBudget() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(100)+ let observed16 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start)+ let attempt = try #require(observed16)+ #expect(attempt.phase == .final)+ schedule.finish(attempt, transientFailure: true, leadTime: 900, now: start.addingTimeInterval(35))+ let observed17 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(35))+ #expect(observed17 == nil)+ }++ @Test func inFlightOrdinaryAttemptCoversFinalPoint() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(900)+ let observed18 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(710))+ let attempt = try #require(observed18)+ schedule.finish(attempt, transientFailure: true, leadTime: 900, now: start.addingTimeInterval(730))+ schedule.coverFinalIfNeeded(attempt, expirationDate: expiration, transientFailure: false, now: start.addingTimeInterval(730))+ let observed19 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(730))+ #expect(observed19 == nil)+ }++ @Test func faultAcrossFinalPointUsesRemainingFinalAttempts() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(900)+ let value = schedule.begin(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(710))+ let attempt = try #require(value)+ schedule.finish(attempt, transientFailure: true, leadTime: 900, now: start.addingTimeInterval(730))+ schedule.coverFinalIfNeeded(attempt, expirationDate: expiration, transientFailure: true, now: start.addingTimeInterval(730))+ let plan = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(730))+ #expect(plan?.evaluationDate == start.addingTimeInterval(745))+ let next = schedule.begin(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(745))+ #expect(next?.phase == .final)+ }++ @Test func extendingExpirationRearmsFinalWithoutRestoringInitialBudget() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(180)+ let observed20 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start)+ let attempt = try #require(observed20)+ schedule.finish(attempt, transientFailure: false, leadTime: 900, now: start)+ let extended = start.addingTimeInterval(1800)+ let observed21 = schedule.plan(expirationDate: extended, leadTime: 900, now: start)+ let plan = try #require(observed21)+ #expect(plan.wakeDate == extended.addingTimeInterval(-180))+ let observed22 = schedule.begin(expirationDate: extended, leadTime: 900, now: plan.evaluationDate)+ let next = try #require(observed22)+ #expect(next.phase != .initial)+ }++ @Test func clockRollbackCannotReopenFinishedFinalRound() throws {+ var schedule = AutoResetSchedule()+ let expiration = start.addingTimeInterval(180)+ let observed23 = schedule.begin(expirationDate: expiration, leadTime: 900, now: start)+ let attempt = try #require(observed23)+ schedule.finish(attempt, transientFailure: false, leadTime: 900, now: start)+ let observed24 = schedule.plan(expirationDate: expiration, leadTime: 900, now: start.addingTimeInterval(-600))+ #expect(observed24 == nil)+ }+}diff --git a/README.en.md b/README.en.mdindex 1abe284..9ae843f 100644--- a/README.en.md+++ b/README.en.md@@ -22,7 +22,7 @@----CodexBar is a menu bar app for macOS 15 and later that brings your Codex account, rate limits, token usage, and live task status into one place.+CodexBar is a menu bar app for macOS that displays your Codex account information, usage limits, token usage, and real-time task status in one place.It can notify you when a task finishes, needs approval, or when your rate limits change. It can also keep your Mac awake while eligible Codex tasks are active.diff --git a/README.md b/README.mdindex e78f3ff..42d7fb4 100644--- a/README.md+++ b/README.md@@ -22,7 +22,7 @@----CodexBar 是面向 macOS 15 及更高版本的菜单栏 App,用于集中展示 Codex 账户、额度、Token 用量和实时任务状态。+CodexBar 是 macOS 的菜单栏 App,用于集中展示 Codex 账户、额度、Token 用量和实时任务状态。它可以在任务完成、等待批准或额度变化时提醒你,也能在符合条件的 Codex 任务存在时自动防止系统睡眠。diff --git a/Shared/CodexBarHelperXPC.swift b/Shared/CodexBarHelperXPC.swiftindex 16aca52..e84bb25 100644--- a/Shared/CodexBarHelperXPC.swift+++ b/Shared/CodexBarHelperXPC.swift@@ -45,7 +45,7 @@ nonisolated enum CodexBarSleepOwnershipState: Int, Sendable {reply: @escaping @Sendable (Int32, Int, Int, Bool) -> Void)- /// helper 更新完成后对同一指纹只执行一次 SleepDisabled 0+ /// helper 更新后按租约和所有权核对, 同一指纹只完成一次func resetSleepAfterUpdate(_ updateIdentifier: String,reply: @escaping @Sendable (Int32) -> Void