Skip to content

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

fix: 修复防睡眠状态恢复与自动重置重试

Bob9582b613bdf2
diff --git a/.swiftlint.yml b/.swiftlint.yml
index 17a4b91..36a2b09 100644
--- a/.swiftlint.yml
+++ b/.swiftlint.yml
@@ -1,6 +1,7 @@
included:
- CodexBar
- CodexBarTests
+ - CodexBarHelperTests
line_length:
warning: 180
diff --git a/AGENTS.md b/AGENTS.md
index 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.pbxproj
index 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.xcscheme
index 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>
<LaunchAction
diff --git a/CodexBar/Controllers/CodexBarAppDelegate.swift b/CodexBar/Controllers/CodexBarAppDelegate.swift
index 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 = nil
hasPreparedForTermination = success
NSApplication.shared.reply(toApplicationShouldTerminate: success)
diff --git a/CodexBar/Models/CodexQuotaModels.swift b/CodexBar/Models/CodexQuotaModels.swift
index 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.swift
index 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.swift
index 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.swift
index 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.swift
index d149721..2fa514f 100644
--- a/CodexBar/Services/AppServer/AccountSession.swift
+++ b/CodexBar/Services/AppServer/AccountSession.swift
@@ -3,7 +3,6 @@ import os
/// 账户连接负责业务解码与重试, 传输和请求日志复用共享 WebSocket
final nonisolated class AccountSession {
- private typealias EncodedMessage = (data: Data, text: String)
private let transport: AppServerSession
private let timeout: TimeInterval
private 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 = nextID
nextID += 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.swift
new file mode 100644
index 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.swift
index 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: String
private let connectionName: String
private 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 = errno
guard 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 = false
while 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 = 0
while 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.swift
index 314e397..cd3cd8d 100644
--- a/CodexBar/Services/CodexStatus/AutoResetController.swift
+++ b/CodexBar/Services/CodexStatus/AutoResetController.swift
@@ -4,823 +4,458 @@ import Foundation
import IOKit
import os
-/// 自动重置的本机状态机
-/// 计划执行前通过 helper 预约系统唤醒, 唤醒后仍经新鲜读取决定是否使用
+@MainActor
+protocol AutoResetWakeActivity: AnyObject {
+ func beginPreventingIdleSleep() -> IOReturn
+ func endPreventingIdleSleep() -> IOReturn
+}
+
+extension SystemSleepService: AutoResetWakeActivity {}
+
+/// 定时器只负责触发, 凭证预算和执行结果由控制器拥有
@MainActor
final 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: String
let 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: Dependencies
private 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 = nil
return
}
-
- 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 = nil
requestEvaluation(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 = trigger
return
}
-
- 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 = generation
evaluationTask = 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: AutoResetRead
do {
- 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.target
switch 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 = nil
return
}
-
- 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.swift
new file mode 100644
index 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.swift
index 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 in
let 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 = true
while 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.swift
index 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.swift
index 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.swift
index 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.swift
index 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: HelperSleepOperations
private var ownership = SleepOwnership.idle
private var transactionID = UUID()
private var lastCompletedUpdateIdentifier: String?
@@ -154,6 +155,12 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
private 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 Sendable
return
}
- let result = setAndVerifySleepDisabled(false)
- guard result.exitCode == 0 else {
- reply(result.exitCode)
+ let exitCode = reconcileSleepAfterUpdate()
+ guard exitCode == 0 else {
+ reply(exitCode)
return
}
let previousUpdateIdentifier = lastCompletedUpdateIdentifier
lastCompletedUpdateIdentifier = updateIdentifier
do {
- try persistOwnership(.idle)
+ // 更新完成不代表系统必须允许睡眠, 有效租约和外部设置仍然保留
+ try persistOwnership(ownership)
} catch {
lastCompletedUpdateIdentifier = previousUpdateIdentifier
logOwnershipWriteFailure(error)
@@ -298,11 +306,23 @@ final class HelperRuntime: NSObject, NSXPCListenerDelegate, @unchecked Sendable
return
}
- 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 Sendable
private 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.swift
index 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: URL
func ensureOwnershipDirectory() throws {
diff --git a/CodexBarHelper/Pmset.swift b/CodexBarHelper/Pmset.swift
index 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.swift
new file mode 100644
index 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.swift
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.md
index 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.md
index 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.swift
index 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