Skip to content

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

refactor: 复用历史数据库连接并统一资源管理

Bobf843f56c4072
diff --git a/CodexBar/Resources/Localizable.xcstrings b/CodexBar/Resources/Localizable.xcstrings
index 398c422..b7e492b 100644
--- a/CodexBar/Resources/Localizable.xcstrings
+++ b/CodexBar/Resources/Localizable.xcstrings
@@ -4993,6 +4993,22 @@
}
}
},
+ "settings.about.openai-status" : {
+ "localizations" : {
+ "en" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "OpenAI Status"
+ }
+ },
+ "zh-Hans" : {
+ "stringUnit" : {
+ "state" : "translated",
+ "value" : "OpenAI 服务状态"
+ }
+ }
+ }
+ },
"settings.about.version" : {
"localizations" : {
"en" : {
diff --git a/CodexBar/Services/History/ActivityDataRecorder.swift b/CodexBar/Services/History/ActivityDataRecorder.swift
index 70f974a..acad0f1 100644
--- a/CodexBar/Services/History/ActivityDataRecorder.swift
+++ b/CodexBar/Services/History/ActivityDataRecorder.swift
@@ -1,19 +1,19 @@
import Foundation
/// 实时通知和历史执行项共用数据库事件身份去重
-actor ActivityDataRecorder {
- private let directoryURL: URL
+nonisolated struct ActivityDataRecorder: Sendable {
+ private let database: HistoryDatabaseStore
init(directoryURL: URL = HistoryStorage.directoryURL()) {
- self.directoryURL = directoryURL
+ database = HistoryDatabaseStore.shared(in: directoryURL)
}
- func record(event: ActivityDataRecord) throws {
+ func record(event: ActivityDataRecord) async throws {
guard event.id != nil else { return }
- try HistoryDatabase(directoryURL: directoryURL).append(AppServerEventRecord(activityData: event))
+ _ = try await database.access { try $0.append(AppServerEventRecord(activityData: event)) }
}
- func record(events: [ActivityDataRecord]) throws {
- try HistoryDatabase(directoryURL: directoryURL).appendActivityData(events)
+ func record(events: [ActivityDataRecord]) async throws {
+ try await database.access { try $0.appendActivityData(events) }
}
}
diff --git a/CodexBar/Services/History/HistoryDatabase.swift b/CodexBar/Services/History/HistoryDatabase.swift
index 2ca5e6c..1929de0 100644
--- a/CodexBar/Services/History/HistoryDatabase.swift
+++ b/CodexBar/Services/History/HistoryDatabase.swift
@@ -1,12 +1,18 @@
import Foundation
import SQLite3
-/// 连接只在所属采集或历史 actor 的同步调用内使用, 事务不跨 await
+/// SQLite 操作同步完成, 应用通过 HistoryDatabaseStore 串行访问共享连接
final nonisolated class HistoryDatabase {
static let filename = "event.db"
private static let schemaVersion: Int32 = 1
private static let transient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
private var connection: OpaquePointer?
+ private var threadSnapshots: [String: CachedThreadSnapshot] = [:]
+
+ private struct CachedThreadSnapshot {
+ let snapshot: TokenUsageThreadSnapshot
+ let accessedAt: Date
+ }
enum Value {
case integer(Int64)
@@ -18,6 +24,15 @@ final nonisolated class HistoryDatabase {
struct Failure: Error {
let code: Int32
let message: String
+
+ var requiresReopening: Bool {
+ switch code & 0xFF {
+ case SQLITE_IOERR, SQLITE_CORRUPT, SQLITE_NOTADB, SQLITE_CANTOPEN, SQLITE_PROTOCOL, SQLITE_READONLY:
+ true
+ default:
+ false
+ }
+ }
}
struct Entry {
@@ -87,6 +102,18 @@ final nonisolated class HistoryDatabase {
sqlite3_close(connection)
}
+ var hasOpenTransaction: Bool {
+ sqlite3_get_autocommit(connection) == 0
+ }
+
+ func canReuseConnection() throws -> Bool {
+ var moved: Int32 = 0
+ let result = sqlite3_file_control(connection, "main", SQLITE_FCNTL_HAS_MOVED, &moved)
+ guard result == SQLITE_OK else { throw failure(result) }
+ guard moved == 0, !hasOpenTransaction else { return false }
+ return try scalar("PRAGMA user_version") == Int64(Self.schemaVersion)
+ }
+
func transaction<T>(isolation _: isolated (any Actor)? = #isolation, _ body: () throws -> T) throws -> T {
try execute("BEGIN IMMEDIATE")
do {
@@ -146,6 +173,15 @@ final nonisolated class HistoryDatabase {
}
}
+ func tokenUsageSnapshot(threadID: String) throws -> TokenUsageThreadSnapshot {
+ let result = try tokenUsageSnapshot(threadSnapshots[threadID]?.snapshot ?? TokenUsageThreadSnapshot(threadID: threadID))
+ threadSnapshots[threadID] = CachedThreadSnapshot(snapshot: result, accessedAt: Date())
+ if threadSnapshots.count > 128, let oldest = threadSnapshots.min(by: { $0.value.accessedAt < $1.value.accessedAt })?.key {
+ threadSnapshots[oldest] = nil
+ }
+ return result
+ }
+
func tokenUsageSnapshot(_ previous: TokenUsageThreadSnapshot) throws -> TokenUsageThreadSnapshot {
var snapshot = previous
try query("""
diff --git a/CodexBar/Services/History/HistoryDatabaseStore.swift b/CodexBar/Services/History/HistoryDatabaseStore.swift
new file mode 100644
index 0000000..a16e8aa
--- /dev/null
+++ b/CodexBar/Services/History/HistoryDatabaseStore.swift
@@ -0,0 +1,69 @@
+import Foundation
+import os
+
+/// 同一目录共用连接, 每次访问在数据库 actor 内同步完成, 事务不跨 await
+actor HistoryDatabaseStore {
+ private static let applicationStore = HistoryDatabaseStore(directoryURL: HistoryStorage.directoryURL().standardizedFileURL)
+ private static let stores = OSAllocatedUnfairLock(initialState: [URL: WeakStore]())
+
+ private struct WeakStore {
+ weak var value: HistoryDatabaseStore?
+ }
+
+ private let directoryURL: URL
+ private var database: HistoryDatabase?
+
+ nonisolated static func shared(in directoryURL: URL) -> HistoryDatabaseStore {
+ let directoryURL = directoryURL.standardizedFileURL
+ if directoryURL == applicationStore.directoryURL {
+ return applicationStore
+ }
+ return stores.withLock { stores in
+ if let store = stores[directoryURL]?.value {
+ return store
+ }
+ stores = stores.filter { $0.value.value != nil }
+ let store = HistoryDatabaseStore(directoryURL: directoryURL)
+ stores[directoryURL] = WeakStore(value: store)
+ return store
+ }
+ }
+
+ private init(directoryURL: URL) {
+ self.directoryURL = directoryURL
+ }
+
+ func access<Value: Sendable>(_ operation: @Sendable (HistoryDatabase) throws -> Value) throws -> Value {
+ try Task.checkCancellation()
+ do {
+ if let database, try !database.canReuseConnection() {
+ self.database = nil
+ }
+ } catch {
+ guard let failure = error as? HistoryDatabase.Failure, failure.requiresReopening else { throw error }
+ // 检查阶段还没有执行本次操作, 可以安全重开连接
+ database = nil
+ }
+ let database: HistoryDatabase
+ if let existing = self.database {
+ database = existing
+ } else {
+ database = try HistoryDatabase(directoryURL: directoryURL)
+ self.database = database
+ }
+ // 失败回滚后仍有事务的连接不能交给下一位调用方
+ defer {
+ if database.hasOpenTransaction {
+ self.database = nil
+ }
+ }
+ do {
+ return try operation(database)
+ } catch {
+ if let failure = error as? HistoryDatabase.Failure, failure.requiresReopening {
+ self.database = nil
+ }
+ throw error
+ }
+ }
+}
diff --git a/CodexBar/Services/History/HistoryService.swift b/CodexBar/Services/History/HistoryService.swift
index 9c71524..14f39e9 100644
--- a/CodexBar/Services/History/HistoryService.swift
+++ b/CodexBar/Services/History/HistoryService.swift
@@ -23,14 +23,14 @@ nonisolated struct HistoryMaintenanceCounts {
/// 原始事件与聚合进度由数据库事务维护, 同步只读取已提交的聚合
actor HistoryService {
- private let directoryURL: URL
+ private let database: HistoryDatabaseStore
private let syncService: SyncService
private let tokenUsageHistory: TokenUsageHistoryStore
private var idleMaintenanceRounds = 0
private var lastRetentionCutoff: Date?
init(directoryURL: URL = HistoryStorage.directoryURL(), syncService: SyncService? = nil, tokenUsageHistory: TokenUsageHistoryStore? = nil) {
- self.directoryURL = directoryURL
+ database = HistoryDatabaseStore.shared(in: directoryURL)
self.syncService = syncService ?? SyncService(directoryURL: HistoryStorage.syncDirectoryURL(in: directoryURL))
self.tokenUsageHistory = tokenUsageHistory ?? TokenUsageHistoryStore(directoryURL: directoryURL)
}
@@ -40,10 +40,10 @@ actor HistoryService {
var pending = Set<String>()
var readable = true
do {
- let database = try HistoryDatabase(directoryURL: directoryURL)
- try database.transaction {
- aggregates = try database.activityDataAggregates()
- pending = try Set(database.pendingActivityDataDates())
+ (aggregates, pending) = try await database.access { database in
+ try database.transaction {
+ try (database.activityDataAggregates(), Set(database.pendingActivityDataDates()))
+ }
}
} catch {
readable = false
@@ -80,18 +80,18 @@ actor HistoryService {
await syncService.pruneLocalCaches(now: now)
var counts = HistoryMaintenanceCounts()
do {
- let database = try HistoryDatabase(directoryURL: directoryURL)
let cutoff = HistoryStorage.retentionCutoffDate(today: now)
if lastRetentionCutoff != cutoff {
- counts.pruned = try database.prune(now: now)
+ counts.pruned = try await database.access { try $0.prune(now: now) }
lastRetentionCutoff = cutoff
}
- let dates = try database.pendingActivityDataDates()
+ let (dates, previous) = try await database.access {
+ try ($0.pendingActivityDataDates(), $0.activityDataAggregates().reduce(into: [String: Int]()) { $0[$1.date] = $1.eventCount ?? 0 })
+ }
counts.dateRange = dates.first.map { $0 == dates.last ? $0 : $0 + ".." + (dates.last ?? $0) } ?? "-"
- let previous = try database.activityDataAggregates().reduce(into: [String: Int]()) { $0[$1.date] = $1.eventCount ?? 0 }
for date in dates {
do {
- let aggregate = try database.aggregateActivityData(date: date, now: now)
+ let aggregate = try await database.access { try $0.aggregateActivityData(date: date, now: now) }
counts.events += (aggregate.eventCount ?? 0) - (previous[date] ?? 0)
counts.written += 1
} catch {
@@ -111,35 +111,34 @@ actor HistoryService {
func rebuildData(for dateKeys: [String], synchronize: Bool) async throws -> HistoryDataRebuildOutcome {
let dates = Set(dateKeys.filter(HistoryStorage.isValidDateKey))
guard !dates.isEmpty else { throw HistoryDataRebuildError.sourceUnavailable }
- let database = try HistoryDatabase(directoryURL: directoryURL)
- let available = try Set(database.dates())
+ let available = try await database.access { try Set($0.dates()) }
var rebuilt: [ActivityDataAggregate] = []
var failed: [String] = []
for date in dates.intersection(available).sorted() {
do {
- try rebuilt.append(database.aggregateActivityData(date: date, rebuilding: true))
+ try await rebuilt.append(database.access { try $0.aggregateActivityData(date: date, rebuilding: true) })
} catch {
failed.append(date)
}
}
- var tokenUsageRebuild = TokenUsageRebuildResult.empty
- var tokenUsageFailed = false
+ let tokenUsageRebuild: TokenUsageRebuildResult
do {
tokenUsageRebuild = try await tokenUsageHistory.rebuild(for: Array(dates))
} catch {
- tokenUsageFailed = true
+ tokenUsageRebuild = TokenUsageRebuildResult(failedDateKeys: dates.sorted())
}
guard !rebuilt.isEmpty || !tokenUsageRebuild.dateKeys.isEmpty else { throw HistoryDataRebuildError.sourceUnavailable }
let snapshot = await loadSnapshot(synchronize: synchronize, trigger: .manual)
let tokenUsageAggregates = await (try? tokenUsageHistory.persistedAggregates()) ?? []
let tokenUsagePending = await syncService.hasPendingTokenUsageUpdates(local: tokenUsageAggregates)
- let activityDataPending = await syncService.hasPendingActivityDataUpdates(local: (try? database.activityDataAggregates()) ?? [])
- let tokenUsageFailures = tokenUsageFailed ? Array(dates).sorted() : tokenUsageRebuild.failedDateKeys
+ let localActivityData = await (try? database.access { try $0.activityDataAggregates() }) ?? []
+ let activityDataPending = await syncService.hasPendingActivityDataUpdates(local: localActivityData)
+ let tokenUsageFailures = tokenUsageRebuild.failedDateKeys
let summary = HistoryDataRebuildSummary(
rebuiltDateCount: Set(rebuilt.map(\.date)).union(tokenUsageRebuild.dateKeys).subtracting(failed).subtracting(tokenUsageFailures).count,
eventCount: rebuilt.reduce(0) { $0 + ($1.eventCount ?? 0) }, isSyncPending: tokenUsagePending || activityDataPending,
failedDateKeys: failed, failedTokenUsageDateKeys: tokenUsageFailures,
- tokenUsageEventCount: tokenUsageRebuild.eventCount, didFailTokenUsageRebuild: tokenUsageFailed || !tokenUsageRebuild.failedDateKeys.isEmpty
+ tokenUsageEventCount: tokenUsageRebuild.eventCount
)
return HistoryDataRebuildOutcome(snapshot: snapshot, summary: summary)
}
@@ -152,7 +151,10 @@ nonisolated struct HistoryDataRebuildSummary: Equatable, Sendable {
let failedDateKeys: [String]
let failedTokenUsageDateKeys: [String]
let tokenUsageEventCount: Int
- let didFailTokenUsageRebuild: Bool
+
+ var didFailTokenUsageRebuild: Bool {
+ !failedTokenUsageDateKeys.isEmpty
+ }
}
nonisolated struct HistoryDataRebuildOutcome {
diff --git a/CodexBar/Services/History/HistoryStorage.swift b/CodexBar/Services/History/HistoryStorage.swift
index 72adff3..7f0c1a3 100644
--- a/CodexBar/Services/History/HistoryStorage.swift
+++ b/CodexBar/Services/History/HistoryStorage.swift
@@ -13,9 +13,10 @@ nonisolated enum HistoryStorage {
root.appendingPathComponent("Sync", isDirectory: true)
}
- static func rebuildableEventDateKeys(in directoryURL: URL = directoryURL()) -> [String] {
+ static func rebuildableEventDateKeys(in directoryURL: URL = directoryURL()) async -> [String] {
let cutoff = dateKey(for: retentionCutoffDate())
- return ((try? HistoryDatabase(directoryURL: directoryURL).dates()) ?? []).filter { $0 >= cutoff }
+ let dates = try? await HistoryDatabaseStore.shared(in: directoryURL).access { try $0.dates() }
+ return (dates ?? []).filter { $0 >= cutoff }
}
static func retentionCutoffDate(today: Date = Date(), calendar: Calendar = .current) -> Date {
diff --git a/CodexBar/Services/History/TokenUsageHistoryStore.swift b/CodexBar/Services/History/TokenUsageHistoryStore.swift
index 14b59aa..7541aac 100644
--- a/CodexBar/Services/History/TokenUsageHistoryStore.swift
+++ b/CodexBar/Services/History/TokenUsageHistoryStore.swift
@@ -2,14 +2,14 @@ import Foundation
import os
/// 原始观测与派生 Token 状态分别提交, 采集租约独立于数据库写锁
-actor TokenUsageHistoryStore {
+final nonisolated class TokenUsageHistoryStore: Sendable {
private let directoryURL: URL
- private var threadSnapshots: [String: TokenUsageThreadSnapshot] = [:]
- private var snapshotAccess: [String: Date] = [:]
- private nonisolated let recordingLease = OSAllocatedUnfairLock<Int32?>(initialState: nil)
+ private let database: HistoryDatabaseStore
+ private let recordingLease = OSAllocatedUnfairLock<Int32?>(initialState: nil)
init(directoryURL: URL = HistoryStorage.directoryURL()) {
self.directoryURL = directoryURL
+ database = HistoryDatabaseStore.shared(in: directoryURL)
}
deinit {
@@ -21,7 +21,7 @@ actor TokenUsageHistoryStore {
}
/// 租约不进入历史读写队列, 慢聚合不能阻塞连接启动和退出
- nonisolated func acquireRecordingLease() throws -> Bool {
+ func acquireRecordingLease() throws -> Bool {
try recordingLease.withLock { lease in
if lease != nil {
return true
@@ -31,7 +31,7 @@ actor TokenUsageHistoryStore {
}
}
- nonisolated func releaseRecordingLease() {
+ func releaseRecordingLease() {
recordingLease.withLock { lease in
if let lease {
JSONFileStorage.releaseLock(lease)
@@ -40,69 +40,60 @@ actor TokenUsageHistoryStore {
}
}
- func appendObservation(_ observation: TokenUsageObservation, now: Date = Date()) throws {
- try HistoryDatabase(directoryURL: directoryURL).append(AppServerEventRecord(tokenUsage: observation, recordedAt: now))
+ func appendObservation(_ observation: TokenUsageObservation, now: Date = Date()) async throws {
+ _ = try await database.access { try $0.append(AppServerEventRecord(tokenUsage: observation, recordedAt: now)) }
}
- func record(_ sample: TokenUsageSample) throws -> TokenUsageThreadSnapshot {
- let database = try HistoryDatabase(directoryURL: directoryURL)
- try database.appendTokenUsage(sample)
- return try snapshot(threadID: sample.threadID, database: database)
- }
-
- func snapshot(threadID: String) throws -> TokenUsageThreadSnapshot {
- try snapshot(threadID: threadID, database: HistoryDatabase(directoryURL: directoryURL))
+ func record(_ sample: TokenUsageSample) async throws -> TokenUsageThreadSnapshot {
+ try await database.access {
+ try $0.appendTokenUsage(sample)
+ return try $0.tokenUsageSnapshot(threadID: sample.threadID)
+ }
}
- private func snapshot(threadID: String, database: HistoryDatabase) throws -> TokenUsageThreadSnapshot {
- let result = try database.tokenUsageSnapshot(threadSnapshots[threadID] ?? TokenUsageThreadSnapshot(threadID: threadID))
- threadSnapshots[threadID] = result
- snapshotAccess[threadID] = Date()
- if threadSnapshots.count > 128, let oldest = snapshotAccess.min(by: { $0.value < $1.value })?.key {
- threadSnapshots[oldest] = nil
- snapshotAccess[oldest] = nil
- }
- return result
+ func snapshot(threadID: String) async throws -> TokenUsageThreadSnapshot {
+ try await database.access { try $0.tokenUsageSnapshot(threadID: threadID) }
}
- func refresh(now: Date = Date()) throws -> [TokenUsageAggregate] {
- try loadSnapshot(now: now).aggregates
+ func refresh(now: Date = Date()) async throws -> [TokenUsageAggregate] {
+ try await loadSnapshot(now: now).aggregates
}
- func loadSnapshot(now: Date = Date()) throws -> TokenUsageHistorySnapshot {
- try readSnapshot(now: now)
+ func loadSnapshot(now: Date = Date()) async throws -> TokenUsageHistorySnapshot {
+ try await readSnapshot(now: now)
}
- private nonisolated func readSnapshot(now: Date) throws -> TokenUsageHistorySnapshot {
- let database = try HistoryDatabase(directoryURL: directoryURL)
- for date in try database.pendingTokenUsageDates() {
+ private func readSnapshot(now: Date) async throws -> TokenUsageHistorySnapshot {
+ let dates = try await database.access { try $0.pendingTokenUsageDates() }
+ for date in dates {
do {
- _ = try database.aggregateTokenUsage(date: date)
+ _ = try await database.access { try $0.aggregateTokenUsage(date: date) }
} catch is CancellationError {
throw CancellationError()
} catch {
// 单日失败保留上次提交结果, 其他日期继续处理
}
}
- return try database.transaction {
- try TokenUsageHistorySnapshot(
- aggregates: retained(database.tokenUsageAggregates(), now: now),
- coverage: database.pendingTokenUsageDates().isEmpty ? .complete : .partial
- )
+ return try await database.access { database in
+ try database.transaction {
+ try TokenUsageHistorySnapshot(
+ aggregates: Self.retained(database.tokenUsageAggregates(), now: now),
+ coverage: database.pendingTokenUsageDates().isEmpty ? .complete : .partial
+ )
+ }
}
}
- func persistedAggregates(now: Date = Date()) throws -> [TokenUsageAggregate] {
- try retained(HistoryDatabase(directoryURL: directoryURL).tokenUsageAggregates(), now: now)
+ func persistedAggregates(now: Date = Date()) async throws -> [TokenUsageAggregate] {
+ try await database.access { try Self.retained($0.tokenUsageAggregates(), now: now) }
}
- func rebuild(for dateKeys: [String]) throws -> TokenUsageRebuildResult {
- let database = try HistoryDatabase(directoryURL: directoryURL)
- let available = try Set(database.tokenUsageDates())
+ func rebuild(for dateKeys: [String]) async throws -> TokenUsageRebuildResult {
+ let available = try await database.access { try Set($0.tokenUsageDates()) }
var result = TokenUsageRebuildResult.empty
for date in Set(dateKeys).intersection(available).sorted() {
do {
- let aggregate = try database.aggregateTokenUsage(date: date, rebuilding: true)
+ let aggregate = try await database.access { try $0.aggregateTokenUsage(date: date, rebuilding: true) }
result.dateKeys.append(date)
result.eventCount += aggregate.eventCount
} catch is CancellationError {
@@ -114,7 +105,7 @@ actor TokenUsageHistoryStore {
return result
}
- private nonisolated func retained(_ aggregates: [TokenUsageAggregate], now: Date) -> [TokenUsageAggregate] {
+ private static func retained(_ aggregates: [TokenUsageAggregate], now: Date) -> [TokenUsageAggregate] {
let cutoff = HistoryStorage.dateKey(for: HistoryStorage.retentionCutoffDate(today: now))
return aggregates.filter { $0.date >= cutoff }
}
diff --git a/CodexBar/Views/Settings/AppSettingsView.swift b/CodexBar/Views/Settings/AppSettingsView.swift
index c364fa8..f45f29b 100644
--- a/CodexBar/Views/Settings/AppSettingsView.swift
+++ b/CodexBar/Views/Settings/AppSettingsView.swift
@@ -205,6 +205,7 @@ private extension AppSettingsView {
static let statusAnimation = Animation.codexStatus
}
+ static let openAIStatusURL = URL(string: "https://status.openai.com")!
static let githubProjectURL = URL(string: "https://github.com/bob-zebedy/CodexBar")!
// MARK: - 分页骨架
@@ -317,6 +318,8 @@ private extension AppSettingsView {
VStack(alignment: .leading, spacing: Metrics.rowSpacing) {
codexVersionSection
LiquidGlassDivider()
+ openAIStatusRow
+ LiquidGlassDivider()
HelperInstallationStatusRow(status: keepAliveController.helperInstallationStatus)
LiquidGlassDivider()
versionRow
@@ -776,10 +779,7 @@ private extension AppSettingsView {
func refreshRebuildableDates() {
Task {
- let dates = await Task.detached(priority: .utility) {
- HistoryStorage.rebuildableEventDateKeys()
- }.value
- rebuildableDates = dates
+ rebuildableDates = await HistoryStorage.rebuildableEventDateKeys()
}
}
@@ -957,14 +957,22 @@ private extension AppSettingsView {
)
}
+ var openAIStatusRow: some View {
+ externalLinkRow(title: "settings.about.openai-status", icon: "waveform.path.ecg.rectangle", destination: Self.openAIStatusURL)
+ }
+
var githubProjectRow: some View {
- Link(destination: Self.githubProjectURL) {
+ externalLinkRow(title: "settings.about.github-project", icon: "globe", destination: Self.githubProjectURL)
+ }
+
+ func externalLinkRow(title: LocalizedStringKey, icon: String, destination: URL) -> some View {
+ Link(destination: destination) {
HStack(spacing: SettingsRowMetrics.spacing) {
- Image(systemName: "globe")
+ Image(systemName: icon)
.frame(width: SettingsRowMetrics.iconWidth)
.foregroundStyle(.tint)
- Text("settings.about.github-project")
+ Text(title)
.foregroundStyle(.primary)
Spacer()
diff --git a/CodexBarTests/Activity/ActivityIsolationTests.swift b/CodexBarTests/Activity/ActivityIsolationTests.swift
index 93bb58f..181b7da 100644
--- a/CodexBarTests/Activity/ActivityIsolationTests.swift
+++ b/CodexBarTests/Activity/ActivityIsolationTests.swift
@@ -248,7 +248,13 @@ extension ActivityIsolationTests {
let entered = Mutex(false)
let release = DispatchSemaphore(value: 0)
defer { release.signal() }
- let blocked = Task { await store.holdForReaderTest(entered: { entered.withLock { $0 = true } }, release: release) }
+ let database = HistoryDatabaseStore.shared(in: directory.url)
+ let blocked = Task {
+ try await database.access { _ in
+ entered.withLock { $0 = true }
+ _ = release.wait(timeout: .now() + 10)
+ }
+ }
for _ in 0 ..< 100 where !entered.withLock({ $0 }) {
try await Task.sleep(for: .milliseconds(10))
}
@@ -276,7 +282,7 @@ extension ActivityIsolationTests {
#expect(ContinuousClock.now - started < .seconds(3))
let countAtStop = batches
release.signal()
- await blocked.value
+ try await blocked.value
// 再次停止等待旧工作循环释放资源, 不能发布已停止连接的状态
_ = await reader.stop()
#expect(batches == countAtStop)
@@ -402,13 +408,6 @@ extension ActivityIsolationTests {
}
}
-private extension TokenUsageHistoryStore {
- func holdForReaderTest(entered: @Sendable () -> Void, release: DispatchSemaphore) {
- entered()
- _ = release.wait(timeout: .now() + 10)
- }
-}
-
extension ActivityIsolationTests {
@Test func fullObservationQueueContinuesBaselineAfterStorageRecovery() async throws {
let directory = try TestDirectory()
diff --git a/CodexBarTests/History/HistoryDatabaseStoreTests.swift b/CodexBarTests/History/HistoryDatabaseStoreTests.swift
new file mode 100644
index 0000000..d8d6261
--- /dev/null
+++ b/CodexBarTests/History/HistoryDatabaseStoreTests.swift
@@ -0,0 +1,231 @@
+import Foundation
+import SQLite3
+import Testing
+
+struct HistoryDatabaseStoreTests {
+ @Test func activityAndTokenWritersUseTheSharedConnection() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ let recorder = ActivityDataRecorder(directoryURL: directory.url)
+ let tokens = TokenUsageHistoryStore(directoryURL: directory.url)
+ let event = Self.event(at: Date())
+ let sample = TokenUsageSample(
+ observedAt: Date(), threadID: "thread", turnID: "turn", turnStartedAt: nil, current: TokenUsageUpdate(total: .zero, last: .zero)
+ )
+ try await store.access {
+ // TEMP 触发器只对创建它的连接生效
+ try $0.execute("CREATE TEMP TRIGGER reject_event BEFORE INSERT ON main.events BEGIN SELECT RAISE(ABORT, 'injected failure'); END")
+ }
+ await #expect(throws: (any Error).self) { try await recorder.record(event: event) }
+ await #expect(throws: (any Error).self) { try await tokens.record(sample) }
+ try await store.access { try $0.execute("DROP TRIGGER reject_event") }
+ try await recorder.record(event: event)
+ _ = try await tokens.record(sample)
+ let count = try await store.access {
+ var count = 0
+ try $0.entries { _ in count += 1 }
+ return count
+ }
+ #expect(count == 2)
+ }
+
+ @Test func historyMaintenanceUsesTheSharedConnection() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let now = Date()
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ let sync = SyncService(directoryURL: HistoryStorage.syncDirectoryURL(in: directory.url), isEnabled: { false })
+ let history = HistoryService(directoryURL: directory.url, syncService: sync)
+ let event = Self.event(at: now)
+ try await ActivityDataRecorder(directoryURL: directory.url).record(event: event)
+ try await store.access {
+ try $0.execute("CREATE TEMP TRIGGER reject_aggregate BEFORE INSERT ON main.aggregates BEGIN SELECT RAISE(ABORT, 'injected failure'); END")
+ }
+ let failed = await history.loadSnapshotWithMaintenance(synchronize: false, trigger: .manual, now: now)
+ #expect(failed.counts?.failed == 1)
+ #expect(try await store.access { try $0.activityDataAggregates().isEmpty })
+ try await store.access { try $0.execute("DROP TRIGGER reject_aggregate") }
+ let recovered = await history.loadSnapshotWithMaintenance(synchronize: false, trigger: .manual, now: now)
+ #expect(recovered.counts?.written == 1)
+ #expect(try await store.access { try $0.activityDataAggregates().first?.eventCount } == 1)
+ }
+
+ @Test func concurrentAccessKeepsFailedTransactionsSeparate() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ try await withThrowingTaskGroup(of: Void.self) { group in
+ for index in 0 ..< 24 {
+ group.addTask {
+ do {
+ try await store.access { database in
+ try database.transaction {
+ try database.execute("INSERT INTO days(date) VALUES (?)", [.text("day-\(index)")])
+ if index.isMultiple(of: 2) {
+ throw InjectedFailure.write
+ }
+ }
+ }
+ } catch InjectedFailure.write {}
+ }
+ }
+ try await group.waitForAll()
+ }
+ let dates = try await store.access { try $0.dates() }
+ #expect(Set(dates) == Set((0 ..< 24).filter { !$0.isMultiple(of: 2) }.map { "day-\($0)" }))
+ }
+
+ @Test func cancellationRollsBackWithoutDiscardingTheConnection() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ try await store.access { try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)") }
+ let task = Task {
+ try await store.access { database in
+ try database.transaction {
+ try database.execute("INSERT INTO days(date) VALUES ('cancelled')")
+ withUnsafeCurrentTask { $0?.cancel() }
+ }
+ }
+ }
+ await #expect(throws: CancellationError.self) { try await task.value }
+ let dates = try await store.access {
+ try $0.execute("INSERT INTO connection_probe VALUES (1)")
+ return try $0.dates()
+ }
+ #expect(dates.isEmpty)
+ try await store.access { try $0.execute("INSERT INTO days(date) VALUES ('committed')") }
+ #expect(try await store.access { try $0.dates() } == ["committed"])
+ }
+
+ @Test func failedOpenCanRecoverOnTheSameStore() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let blocker = try directory.write("not a database", to: HistoryDatabase.filename)
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ await #expect(throws: (any Error).self) { try await store.access { try $0.dates() } }
+ try FileManager.default.removeItem(at: blocker)
+ #expect(try await store.access { try $0.dates() }.isEmpty)
+ }
+
+ @Test func reusedConnectionSeesOtherConnectionCommitsAndKeepsDirectoriesSeparate() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let firstURL = directory.url.appendingPathComponent("first", isDirectory: true)
+ let secondURL = directory.url.appendingPathComponent("second", isDirectory: true)
+ let first = HistoryDatabaseStore.shared(in: firstURL)
+ let second = HistoryDatabaseStore.shared(in: secondURL)
+ #expect(try await first.access { try $0.dates() }.isEmpty)
+ try HistoryDatabase(directoryURL: firstURL).execute("INSERT INTO days(date) VALUES ('external')")
+ #expect(try await first.access { try $0.dates() } == ["external"])
+ #expect(try await second.access { try $0.dates() }.isEmpty)
+ }
+
+ @Test func replacingDatabaseReopensConnectionAndDiscardsThreadSnapshots() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ let tokens = TokenUsageHistoryStore(directoryURL: directory.url)
+ let now = Date()
+ let first = Self.observation(tokens: 5, at: now)
+ try await tokens.appendObservation(first)
+ #expect(try await tokens.snapshot(threadID: "thread").turns["turn"]?.totalTokens == 5)
+ let replacementDirectory = directory.url.appendingPathComponent("replacement", isDirectory: true)
+ let replacement = Self.observation(tokens: 20, at: now)
+ try HistoryDatabase(directoryURL: replacementDirectory).append(AppServerEventRecord(tokenUsage: replacement, recordedAt: now))
+ let url = directory.url.appendingPathComponent(HistoryDatabase.filename)
+ try FileManager.default.moveItem(at: url, to: directory.url.appendingPathComponent("previous.db"))
+ try FileManager.default.moveItem(at: replacementDirectory.appendingPathComponent(HistoryDatabase.filename), to: url)
+ #expect(try await tokens.snapshot(threadID: "thread").turns["turn"]?.totalTokens == 20)
+ #expect(try await store.access { try $0.dates() } == [HistoryStorage.dateKey(for: now)])
+ }
+
+ @Test func threadSnapshotsRemainAccurateBeyondCacheCapacity() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let tokens = TokenUsageHistoryStore(directoryURL: directory.url)
+ let now = Date()
+ for index in 0 ..< 129 {
+ let threadID = "thread-\(index)"
+ try await tokens.appendObservation(Self.observation(tokens: 5, at: now, threadID: threadID))
+ #expect(try await tokens.snapshot(threadID: threadID).turns["turn"]?.totalTokens == 5)
+ }
+ let updated = try await tokens.record(TokenUsageSample(
+ observedAt: now, threadID: "thread-0", turnID: "turn", turnStartedAt: nil,
+ current: Self.observation(tokens: 9, at: now).current
+ ))
+ #expect(updated.turns["turn"]?.totalTokens == 9)
+ for index in 0 ..< 129 {
+ #expect(try await tokens.snapshot(threadID: "thread-\(index)").turns["turn"]?.totalTokens == (index == 0 ? 9 : 5))
+ }
+ }
+
+ @Test func schemaChangesAreValidatedBeforeReusingConnection() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ try await store.access { try $0.execute("INSERT INTO days(date) VALUES ('preserved')") }
+ let external = try HistoryDatabase(directoryURL: directory.url)
+ try external.execute("PRAGMA user_version = 999")
+ await #expect(throws: StorageCompatibilityError.unsupportedFormat("HistoryDatabase", 999)) {
+ try await store.access { try $0.dates() }
+ }
+ #expect(try external.dates() == ["preserved"])
+ try external.execute("PRAGMA user_version = 1")
+ #expect(try await store.access { try $0.dates() } == ["preserved"])
+ }
+
+ @Test func ioFailureReopensConnectionWithoutReplayingCommittedWork() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ await #expect(throws: HistoryDatabase.Failure.self) {
+ try await store.access {
+ try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)")
+ try $0.execute("INSERT INTO days(date) VALUES ('committed')")
+ throw HistoryDatabase.Failure(code: SQLITE_IOERR, message: "injected failure")
+ }
+ }
+ let dates = try await store.access {
+ try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)")
+ return try $0.dates()
+ }
+ #expect(dates == ["committed"])
+ }
+
+ @Test func lockContentionPreservesConnection() async throws {
+ let directory = try TestDirectory()
+ defer { try? directory.remove() }
+ let store = HistoryDatabaseStore.shared(in: directory.url)
+ try await store.access { try $0.execute("CREATE TEMP TABLE connection_probe(value INTEGER)") }
+ let external = try HistoryDatabase(directoryURL: directory.url)
+ try external.execute("BEGIN EXCLUSIVE")
+ do {
+ _ = try await store.access { try $0.dates() }
+ Issue.record("Expected the external writer to block the read")
+ } catch let error as HistoryDatabase.Failure {
+ #expect(error.code == SQLITE_BUSY)
+ }
+ try external.execute("ROLLBACK")
+ try await store.access { try $0.execute("INSERT INTO connection_probe VALUES (1)") }
+ }
+
+ private static func event(at date: Date) -> ActivityDataRecord {
+ ActivityDataRecord(
+ timestamp: date, name: ActivityDataEventKind.turnStarted.rawValue, origin: .main,
+ cwd: nil, toolName: nil, model: nil, effort: nil, threadID: "thread", turnID: "turn", agentThreadID: nil, id: "event"
+ )
+ }
+
+ private static func observation(tokens: Int64, at date: Date, threadID: String = "thread") -> TokenUsageObservation {
+ let usage = TokenUsage(inputTokens: tokens, cachedInputTokens: 0, cacheWriteInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0, totalTokens: tokens)
+ return TokenUsageObservation(
+ observedAt: date, threadID: threadID, turnID: "turn", previous: .zero, current: TokenUsageUpdate(total: usage, last: usage)
+ )
+ }
+
+ private enum InjectedFailure: Error {
+ case write
+ }
+}
diff --git a/CodexBarTests/History/HistoryDatabaseTests.swift b/CodexBarTests/History/HistoryDatabaseTests.swift
index 5798996..019a273 100644
--- a/CodexBarTests/History/HistoryDatabaseTests.swift
+++ b/CodexBarTests/History/HistoryDatabaseTests.swift
@@ -27,7 +27,7 @@ struct HistoryDatabaseTests {
#expect(rebuilt.syncedAggregate.metrics.toolCallCount == 3)
}
- @Test func rebuildableDatesIncludeActivityAndTokenOnlyDaysWithinRetention() throws {
+ @Test func rebuildableDatesIncludeActivityAndTokenOnlyDaysWithinRetention() async throws {
let directory = try TestDirectory()
defer { try? directory.remove() }
let database = try HistoryDatabase(directoryURL: directory.url)
@@ -42,7 +42,7 @@ struct HistoryDatabaseTests {
let observation = TestFixtures.tokenUsageObservation(at: date, tokenUsage: .zero)
try database.append(AppServerEventRecord(tokenUsage: observation, recordedAt: now))
}
- #expect(HistoryStorage.rebuildableEventDateKeys(in: directory.url) == [cutoff, yesterday, now].map(HistoryStorage.dateKey(for:)))
+ #expect(await HistoryStorage.rebuildableEventDateKeys(in: directory.url) == [cutoff, yesterday, now].map(HistoryStorage.dateKey(for:)))
}
@Test func committedEventsSurviveRestartAndDeduplicate() throws {
diff --git a/CodexBarTests/Support/TestSupport.swift b/CodexBarTests/Support/TestSupport.swift
index 7cf4c0a..b1eb6f0 100644
--- a/CodexBarTests/Support/TestSupport.swift
+++ b/CodexBarTests/Support/TestSupport.swift
@@ -161,11 +161,11 @@ nonisolated extension SyncedActivityData {
/// 测试夹具按采集器的原始记录与缓存聚合两个步骤写入
extension TokenUsageHistoryStore {
- func recordObservations(_ observations: [TokenUsageObservation], now: Date = Date()) throws -> [TokenUsageAggregate] {
- _ = try refresh(now: now)
+ func recordObservations(_ observations: [TokenUsageObservation], now: Date = Date()) async throws -> [TokenUsageAggregate] {
+ _ = try await refresh(now: now)
for observation in observations {
- try appendObservation(observation, now: now)
+ try await appendObservation(observation, now: now)
}
- return try refresh(now: now)
+ return try await refresh(now: now)
}
}
diff --git a/CodexBarTests/Sync/SyncRecoveryTests.swift b/CodexBarTests/Sync/SyncRecoveryTests.swift
index 66f33f9..fd02aa4 100644
--- a/CodexBarTests/Sync/SyncRecoveryTests.swift
+++ b/CodexBarTests/Sync/SyncRecoveryTests.swift
@@ -675,7 +675,9 @@ extension SyncRecoveryTests {
@Test func repeatedRebuildKeepsSourceAndNeedsNoSeparateAcknowledgement() async throws {
let fixture = try await HistoryRebuildFixture()
defer { try? fixture.directory.remove() }
- _ = try await fixture.history.rebuildData(for: [fixture.date], synchronize: false)
+ let initial = try await fixture.history.rebuildData(for: [fixture.date], synchronize: false)
+ #expect(initial.summary.failedTokenUsageDateKeys.isEmpty)
+ #expect(!initial.summary.didFailTokenUsageRebuild)
_ = try await fixture.history.rebuildData(for: [fixture.date], synchronize: true)
let state = try HistoryDatabase(directoryURL: fixture.directory.url)
#expect(try state.activityDataAggregates().first == fixture.local)
@@ -762,6 +764,28 @@ extension SyncRecoveryTests {
#expect(await fixture.database.activityDataRecords().count == 1)
}
+ @Test func unavailableTokenUsageHistoryMarksAllRequestedDatesFailed() async throws {
+ let fixture = try await HistoryRebuildFixture()
+ defer { try? fixture.directory.remove() }
+ let brokenDirectory = try TestDirectory()
+ defer { try? brokenDirectory.remove() }
+ _ = try brokenDirectory.write(Data("broken".utf8), to: HistoryDatabase.filename)
+ let history = HistoryService(
+ directoryURL: fixture.directory.url, syncService: fixture.sync,
+ tokenUsageHistory: TokenUsageHistoryStore(directoryURL: brokenDirectory.url)
+ )
+ let date = try #require(CodexDateFormat.dayDate(from: fixture.date))
+ let dates = [fixture.date, HistoryStorage.dateKey(for: date.addingTimeInterval(-86400))]
+ let result = try await history.rebuildData(for: dates, synchronize: false)
+ #expect(result.summary.failedTokenUsageDateKeys == dates.sorted())
+ #expect(result.summary.didFailTokenUsageRebuild)
+ #expect(result.summary.rebuiltDateCount == 0)
+ #expect(result.summary.eventCount == 1)
+ #expect(result.summary.tokenUsageEventCount == 0)
+ #expect(result.summary.failedDateKeys.isEmpty)
+ #expect(try await Self.activityDataEventCount(fixture.database.activityDataRecords().first) == 9)
+ }
+
@Test func partialTokenUsageFailureIsReportedWithoutClaimingWholeDaySuccess() async throws {
let fixture = try await HistoryRebuildFixture()
defer { try? fixture.directory.remove() }
diff --git a/Scripts/performance/README.md b/Scripts/performance/README.md
index 4ea9db2..05299d3 100644
--- a/Scripts/performance/README.md
+++ b/Scripts/performance/README.md
@@ -37,7 +37,7 @@ python3 -m Scripts.performance \
| `--app PATH` | App 路径,默认 `/Applications/CodexBar.app` |
| `--pid PID` | 指定待测试进程,存在多个 App 实例时使用 |
| `--preset NAME` | 选择 `quick`、`standard` 或 `extended` |
-| `--output PATH` | 采集时指定新目录,重新生成报告时指定 HTML 文件 |
+| `--output VALUE` | 采集时追加目录名后缀,重新生成报告时指定 HTML 文件路径 |
| `--workload TEXT` | 记录测试场景说明 |
| `--baseline PATH` | 指定基线 `performance.json` |
| `--cpu-mean-budget NUMBER` | 各阶段平均 CPU 上限,单位为 `%` |
@@ -50,7 +50,7 @@ python3 -m Scripts.performance \
默认输出到仓库根目录下的 `Performance/{version}({build})-{preset}-YYYYMMDDHHmmss/`,日期和时间取测试启动时的本地时间,精确到秒。版本和构建号分别读取 `Config/Version.xcconfig` 中的 `MARKETING_VERSION` 和 `CURRENT_PROJECT_VERSION`,保留版本号中的点号。
```text
-Performance/4.1.1(123)-extended-20261024140000/
+Performance/4.1.1(111)-extended-20261024140000/
├── performance.html
├── performance.json
├── schemas.json
@@ -62,12 +62,14 @@ Performance/4.1.1(123)-extended-20261024140000/
`performance.html` 用于查看报告,`performance.json` 用于基线比较和重新生成报告,`*.trace` 可用 Instruments 打开。目录内同时保存采样 XML、命令日志和工具源码快照。
-已有同名目录时,脚本会报错而不覆盖已有结果。可用 `--output` 指定其他新目录:
+已有同名目录时,脚本会报错而不覆盖已有结果。采集时可用 `--output` 在默认目录名后追加 `-{后缀}`,后缀不能为空或包含 `/`:
```sh
-python3 -m Scripts.performance --preset quick --output Performance/idle-01
+python3 -m Scripts.performance --preset quick --output idle
```
+例如,输出目录为 `Performance/4.1.1(111)-quick-20261024140000-idle/`
+
## 基线比较
先采集基线:
@@ -75,15 +77,15 @@ python3 -m Scripts.performance --preset quick --output Performance/idle-01
```sh
python3 -m Scripts.performance \
--preset quick \
- --output Performance/idle-01
+ --output idle
```
-再次测试时指定基线文件:
+再次测试时指定实际生成目录中的基线文件,例如:
```sh
python3 -m Scripts.performance \
--preset quick \
- --baseline Performance/idle-01/performance.json
+ --baseline 'Performance/4.1.1(111)-quick-20261024140000-idle/performance.json'
```
两个报告均完整,且应用标识、格式、测试配置与环境条件匹配时,报告计算各阶段的 CPU 均值和 Footprint 中位数差值;条件不匹配时列出原因。
@@ -115,13 +117,13 @@ python3 -m Scripts.performance \
从已有 JSON 重新生成 HTML 报告:
```sh
-python3 -m Scripts.performance --render Performance/idle-01/performance.json
+python3 -m Scripts.performance --render 'Performance/4.1.1(111)-quick-20261024140000-idle/performance.json'
```
默认更新 JSON 同目录的 `performance.html`。使用 `--output` 指定另一个 HTML 文件:
```sh
python3 -m Scripts.performance \
- --render Performance/idle-01/performance.json \
- --output Performance/idle-01/performance-updated.html
+ --render 'Performance/4.1.1(111)-quick-20261024140000-idle/performance.json' \
+ --output 'Performance/4.1.1(111)-quick-20261024140000-idle/performance-updated.html'
```
diff --git a/Scripts/performance/__main__.py b/Scripts/performance/__main__.py
index e39dbad..ab8e7a0 100644
--- a/Scripts/performance/__main__.py
+++ b/Scripts/performance/__main__.py
@@ -35,7 +35,7 @@ class Arguments(argparse.Namespace):
app: Path
pid: int | None
preset: str
- output: Path | None
+ output: str | None
workload: str
baseline: Path | None
cpu_mean_budget: float | None
@@ -50,7 +50,7 @@ def main() -> int:
parser.add_argument("--app", type=Path, default=Path("/Applications/CodexBar.app"))
parser.add_argument("--pid", type=int)
parser.add_argument("--preset", choices=PRESETS, default="standard")
- parser.add_argument("--output", type=Path)
+ parser.add_argument("--output", help="Append a suffix to the recording directory name, or set the HTML path with --render")
parser.add_argument("--workload", default="Natural workload; UI and active tasks uncontrolled")
parser.add_argument("--baseline", type=Path)
parser.add_argument("--cpu-mean-budget", type=float)
@@ -59,30 +59,32 @@ def main() -> int:
args = parser.parse_args(namespace=Arguments())
if args.render:
render_data = cast(Report, json.loads(args.render.read_text()))
- destination = args.output or args.render.parent / "performance.html"
+ destination = Path(args.output) if args.output is not None else args.render.parent / "performance.html"
write_report(render_data, destination)
print(destination)
return 0
for value in (args.cpu_mean_budget, args.footprint_budget):
if value is not None and (not 0 < value < float("inf")):
parser.error("Budgets must be finite positive numbers")
- output = args.output
- if output is None:
- version_config = ROOT / "Config/Version.xcconfig"
- try:
- version_text = version_config.read_text()
- except OSError as error:
- parser.error(f"Cannot read {version_config}: {error}")
- version_match = re.search(r"(?m)^\s*MARKETING_VERSION\s*=\s*(\d+(?:\.\d+)+)\s*$", version_text)
- if version_match is None:
- parser.error(f"Missing or invalid MARKETING_VERSION in {version_config}")
- build_match = re.search(r"(?m)^\s*CURRENT_PROJECT_VERSION\s*=\s*(\d+(?:\.\d+)*)\s*$", version_text)
- if build_match is None:
- parser.error(f"Missing or invalid CURRENT_PROJECT_VERSION in {version_config}")
- version = f"{version_match.group(1)}({build_match.group(1)})"
- timestamp = dt.datetime.now().strftime("%Y%m%d%H%M%S")
- output = ROOT / "Performance" / f"{version}-{args.preset}-{timestamp}"
- output = output.resolve()
+ if args.output is not None and (not args.output or "/" in args.output):
+ parser.error("--output must be a non-empty directory name suffix without '/' when recording")
+ version_config = ROOT / "Config/Version.xcconfig"
+ try:
+ version_text = version_config.read_text()
+ except OSError as error:
+ parser.error(f"Cannot read {version_config}: {error}")
+ version_match = re.search(r"(?m)^\s*MARKETING_VERSION\s*=\s*(\d+(?:\.\d+)+)\s*$", version_text)
+ if version_match is None:
+ parser.error(f"Missing or invalid MARKETING_VERSION in {version_config}")
+ build_match = re.search(r"(?m)^\s*CURRENT_PROJECT_VERSION\s*=\s*(\d+(?:\.\d+)*)\s*$", version_text)
+ if build_match is None:
+ parser.error(f"Missing or invalid CURRENT_PROJECT_VERSION in {version_config}")
+ version = f"{version_match.group(1)}({build_match.group(1)})"
+ timestamp = dt.datetime.now().strftime("%Y%m%d%H%M%S")
+ output_name = f"{version}-{args.preset}-{timestamp}"
+ if args.output is not None:
+ output_name += f"-{args.output}"
+ output = (ROOT / "Performance" / output_name).resolve()
try:
output.mkdir(parents=True, exist_ok=False)
except OSError as error: