CodexBar

0.32.5

Tue, 09 Jun 2026 08:30:33 +0100

CodexBar 0.32.5

Added

Localization: add French as a selectable app language (#1241). Thanks @Yuxin-Qiao!
Localization: add Ukrainian as a selectable app language (#1250). Thanks @Yuxin-Qiao!
Localization: add Dutch as a selectable app language (#1252). Thanks @Yuxin-Qiao!
Localization: add Vietnamese as a selectable app language (#1247). Thanks @Yuxin-Qiao!

Fixed

Menu bar: keep provider switching inside AppKit's menu-tracking transaction and defer structural dropdown rebuilds until mouse-up completes, preventing intermittent hangs when moving between providers and Overview.
Localization: cache resolved localized bundles so repeated menu/status text lookups no longer hit disk on the main thread (#1355, fixes #1347). Thanks @Yuxin-Qiao!
Menu bar: size hosted chart submenus directly instead of spinning up throwaway SwiftUI hosting controllers during menu layout (#1352). Thanks @Yuxin-Qiao!
Menu bar: avoid recomputing expensive readiness signatures on closed-menu store ticks while preserving root-open refresh correctness for deferred observations (#1351). Thanks @Yuxin-Qiao!
Menu bar: defer Quit from the status menu until AppKit menu tracking unwinds so shutdown does not wedge Dock autohide state (#1354, fixes #1353). Thanks @jskoiz!
Claude: remove transient ClaudeProbe session artifacts after CLI usage polls so background refreshes no longer fill Claude Code project history with CodexBar /usage sessions (#1301). Thanks @LPFchan and @matthewod11-stack!
Menu bar: keep z.ai overview rows with detail submenus in Overview so hovering quota details no longer recurses into a nested provider menu (#1279, fixes #1246). Thanks @RajvardhanPatil07!
Codex: backfill visible-account reset timestamps and missing 5-hour/weekly window metadata from same-workspace plan history so segmented multi-account JSON keeps machine-readable reset data (#1283). Thanks @callmepopo!
Antigravity: detect CLI local language-server processes and allow empty CSRF tokens only for explicit CLI matches so Antigravity CLI quota usage renders without weakening IDE CSRF detection (#1341). Thanks @oyaah!
Menu bar: skip closed attached-menu rebuilds during stale background data-refresh ticks so closed dropdowns are not pre-warmed while the user is not interacting (#1291). Thanks @Nicolas0315!
Cursor: show deficit and run-out pace details for 30-day Total, Auto, and API billing-cycle usage rows (#1336). Thanks @dhruv-anand-aintech!
Codex: time out stalled managed codex login processes so account switches no longer stay stuck in progress after OAuth completes (#1330). Thanks @dhruv-anand-aintech!
Codex Spark: show the same deficit and run-out pace details as the core Codex quota lanes for 5-hour and weekly model limits (#1335). Thanks @dhruv-anand-aintech!
Antigravity: make the automatic menu-bar summary choose the most constrained family quota so an exhausted Gemini lane is no longer hidden by a full Claude lane (#1334). Thanks @dhruv-anand-aintech!
Performance: memoize models.dev cost catalog load outcomes so large Codex history scans no longer re-read and decode the same cache file per row (#1322, refs #1311). Thanks @turbothad!
Menu bar: compute Claude pace/reserve from the selected menu-bar metric window so Primary (Session) no longer pairs the session percentage with the weekly reserve (#1302). Thanks @outfoxer!
Menu bar: defer merged-menu close rebuilds and cache repeated menu-card height measurements so dismissing or rapidly switching the merged dropdown avoids rebuilding SwiftUI-backed cards on the main thread (#1274, #1286, #1314). Thanks @hhh2210!
Menu bar: keep merged provider tab selection from invalidating broad settings observers so switching providers no longer triggers background refresh and status-icon work.
Menu bar: observe a compact icon-state signature so merged status icons no longer redraw for provider snapshot changes that cannot affect the visible icon (#1297). Thanks @hhh2210!
Menu bar: keep provider-switcher quota bars from replacing Auto Layout constraints when the visible ratio is unchanged, making tab switches responsive with many providers enabled (#1303, #1315). Thanks @juanjoseluisgarcia!
Kiro: retry login-shell PATH capture when CLI discovery races a slow cold shell startup, so kiro-cli is no longer stuck as missing for the whole app session (#1316). Thanks @bt-justtrack!

View full changelog

0.32.4

Tue, 02 Jun 2026 15:43:46 +0100

0.32.2

Mon, 01 Jun 2026 04:43:41 +0100

CodexBar 0.32.2

Added

QA: document the live CodexBar e2e flow and add a redacted provider-matrix helper for packaged CLI smoke tests.

Fixed

Menu bar: add breathing room to compact Codex account rows so the provider, account, status, and plan labels no longer hug the row edges.
Performance: make Codex token-cost scanning faster and more memory-efficient on large local session corpora.

View full changelog

0.14.0

Thu, 25 Dec 2025 03:56:15 +0100

: NSHostingView { @MainActor final class MenuCardItemHostingView: NSHostingView, MenuCardHighlighting, MenuCardMeasuring { - private let highlightState: MenuCardHighlightState - private let onClick: (() -> Void)? + let highlightState: MenuCardHighlightState + private var onClick: (() -> Void)? + private var hasClickRecognizer = false override var allowsVibrancy: Bool { true @@ -100,12 +101,29 @@ final class MenuCardItemHostingView: NSHostingView, Menu self.onClick = onClick super.init(rootView: rootView) if onClick != nil { - let recognizer = NSClickGestureRecognizer(target: self, action: #selector(self.handlePrimaryClick(_:))) - recognizer.buttonMask = 0x1 - self.addGestureRecognizer(recognizer) + self.installClickRecognizer() } } + /// Reuses this hosting view for a rebuilt card with the same identity: the replaced + /// `rootView` is diffed in place by SwiftUI instead of tearing down and recreating the + /// hosting view and its graph. Callers must construct `rootView` around this view's own + /// `highlightState` so menu hover highlighting keeps driving the rendered content. + func prepareForReuse(rootView: Content, onClick: (() -> Void)?) { + self.rootView = rootView + self.onClick = onClick + if onClick != nil, !self.hasClickRecognizer { + self.installClickRecognizer() + } + } + + private func installClickRecognizer() { + let recognizer = NSClickGestureRecognizer(target: self, action: #selector(self.handlePrimaryClick(_:))) + recognizer.buttonMask = 0x1 + self.addGestureRecognizer(recognizer) + self.hasClickRecognizer = true + } + required init(rootView: Content) { self.highlightState = MenuCardHighlightState() self.onClick = nil diff --git a/Sources/CodexBar/StatusItemController+MenuReconcile.swift b/Sources/CodexBar/StatusItemController+MenuReconcile.swift new file mode 100644 index 00000000..c8f0e1f1 --- /dev/null +++ b/Sources/CodexBar/StatusItemController+MenuReconcile.swift @@ -0,0 +1,132 @@ +import AppKit + +/// Pre-harvest snapshot of one live content row, captured before card views are detached +/// into the recycle pool so reconciliation can still compare row shapes afterwards. +struct MenuRowShape { + let isSeparator: Bool + let id: String? + let viewClassName: String? +} + +extension StatusItemController { + func menuContentShapes(in menu: NSMenu, fromIndex: Int) -> [MenuRowShape] { + guard fromIndex >= 0, fromIndex <= menu.items.count else { return [] } + return menu.items[fromIndex...].map { item in + MenuRowShape( + isSeparator: item.isSeparatorItem, + id: item.representedObject as? String, + viewClassName: item.view.map { String(describing: type(of: $0)) }) + } + } + + /// Position-wise in-place reconciliation: live rows whose shape matches the freshly + /// built content (separator placement, card identifier, view class) are updated in + /// place — views transplanted, plain rows recopied — and only the mismatched middle + /// span is removed and reinserted. Matching runs from both ends, so the expensive card + /// rows at the top and the shared action rows at the bottom survive even a provider + /// switch whose middle sections differ; AppKit then relayouts the open tracked menu for + /// the few changed rows instead of once per row. + func reconcileMenuContent( + _ menu: NSMenu, + fromIndex: Int, + shapes: [MenuRowShape], + with scratch: NSMenu) + { + defer { self.finishReconciledHighlightTracking(in: menu) } + let newItems = scratch.items + scratch.removeAllItems() + guard menu.items.count - fromIndex == shapes.count else { + // The live region changed underneath the snapshot; replace it wholesale. + self.replaceMenuContent(menu, fromIndex: fromIndex, with: newItems) + return + } + + func updatable(_ shape: MenuRowShape, _ newItem: NSMenuItem) -> Bool { + guard shape.isSeparator == newItem.isSeparatorItem else { return false } + if shape.isSeparator { return true } + guard shape.id == newItem.representedObject as? String else { return false } + return shape.viewClassName == newItem.view.map { String(describing: type(of: $0)) } + } + + var prefix = 0 + while prefix < min(shapes.count, newItems.count), updatable(shapes[prefix], newItems[prefix]) { + prefix += 1 + } + var suffix = 0 + while suffix < min(shapes.count, newItems.count) - prefix, + updatable(shapes[shapes.count - 1 - suffix], newItems[newItems.count - 1 - suffix]) + { + suffix += 1 + } + + for offset in 0.. fromIndex { + menu.removeItem(at: fromIndex) + } + for item in newItems { + menu.addItem(item) + } + } + + private func updateMenuItemInPlace(_ liveItem: NSMenuItem, from newItem: NSMenuItem) { + if liveItem.isSeparatorItem { return } + let remainsHighlighted = liveItem.menu.map { + self.highlightedMenuItems[ObjectIdentifier($0)] === liveItem + } ?? false + // Detach from the scratch item first so a view or submenu is never referenced by + // two menu items at once. + let view = newItem.view + newItem.view = nil + let submenu = newItem.submenu + newItem.submenu = nil + liveItem.view = view + (view as? MenuCardHighlighting)?.setHighlighted(remainsHighlighted) + liveItem.submenu = submenu + liveItem.title = newItem.title + liveItem.attributedTitle = newItem.attributedTitle + liveItem.action = newItem.action + liveItem.target = newItem.target + liveItem.representedObject = newItem.representedObject + liveItem.state = newItem.state + liveItem.isEnabled = newItem.isEnabled + liveItem.image = newItem.image + liveItem.toolTip = newItem.toolTip + liveItem.keyEquivalent = newItem.keyEquivalent + liveItem.keyEquivalentModifierMask = newItem.keyEquivalentModifierMask + liveItem.indentationLevel = newItem.indentationLevel + if #available(macOS 14.4, *) { + liveItem.subtitle = newItem.subtitle + } + } +} diff --git a/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift b/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift new file mode 100644 index 00000000..c55794f4 --- /dev/null +++ b/Sources/CodexBar/StatusItemController+MenuSmartUpdate.swift @@ -0,0 +1,137 @@ +import AppKit +import CodexBarCore +import SwiftUI + +extension StatusItemController { + /// Smart update: rebuild everything below the provider switcher while keeping the switcher view intact. + struct MenuUpdateContext { + let provider: UsageProvider? + let currentProvider: UsageProvider + let switcherSelection: ProviderSwitcherSelection + let menuWidth: CGFloat + let codexAccountDisplay: CodexAccountMenuDisplay? + let tokenAccountDisplay: TokenAccountMenuDisplay? + let openAIContext: OpenAIWebContext + let descriptor: MenuDescriptor + } + + /// Smart update: rebuild everything below the provider switcher while keeping the switcher view intact. + func updateMenuContentPreservingSwitcher( + _ menu: NSMenu, + context: MenuUpdateContext) + { + self.performMenuMutationWithoutAnimation { + let contentStartIndex = self.providerSwitcherContentStartIndex(in: menu) + if let switcherView = menu.items.first?.view as? ProviderSwitcherView { + switcherView.updateSelection(context.switcherSelection) + switcherView.updateQuotaIndicators() + } + let outgoingSelection = self.lastMergedMenuContentSelection + let isSelectionSwitch = outgoingSelection != nil && outgoingSelection != context.switcherSelection + let enabledProviders = self.store.enabledProvidersForDisplay() + + if isSelectionSwitch, + let outgoingSelection, + self.hasReusableMergedSwitcherContent( + for: context.switcherSelection, + in: menu, + menuWidth: context.menuWidth, + codexAccountDisplay: context.codexAccountDisplay, + tokenAccountDisplay: context.tokenAccountDisplay) + { + // Instant path: the incoming tab reattaches wholesale, so park the outgoing + // items for an equally instant switch-back. + self.cacheVisibleMergedSwitcherContent( + in: menu, + selection: outgoingSelection, + contentStartIndex: contentStartIndex, + menuWidth: context.menuWidth) + while menu.items.count > contentStartIndex { + menu.removeItem(at: contentStartIndex) + } + self.rememberMergedSwitcherState(enabledProviders, context.switcherSelection) + if self.addCachedMergedSwitcherContent( + for: context.switcherSelection, + to: menu, + menuWidth: context.menuWidth, + codexAccountDisplay: context.codexAccountDisplay, + tokenAccountDisplay: context.tokenAccountDisplay) + { + return + } + self.addSwitcherScopedMenuContent(into: menu, captureMenu: menu, context: context) + self.cacheVisibleMergedSwitcherContent( + in: menu, + selection: context.switcherSelection, + contentStartIndex: contentStartIndex, + menuWidth: context.menuWidth, + contentVersion: self.menuContentVersion) + return + } + + // Rebuild path (data tick, or switch whose incoming tab must be built): recycle + // the outgoing hosting views and reconcile in place when the row skeleton is + // unchanged, so an open tracked menu sees content mutations instead of item + // churn. The fresh content is built into a detached scratch menu while its + // interaction closures capture the live menu they will serve. + let shapes = self.menuContentShapes(in: menu, fromIndex: contentStartIndex) + self.harvestRecyclableMenuCardViews( + in: menu, + fromIndex: contentStartIndex, + displacedSelection: outgoingSelection, + preserveHighlightedItem: true) + defer { self.clearMenuCardViewRecyclePool() } + self.rememberMergedSwitcherState(enabledProviders, context.switcherSelection) + let scratch = NSMenu() + scratch.autoenablesItems = false + self.addSwitcherScopedMenuContent(into: scratch, captureMenu: menu, context: context) + self.reconcileMenuContent(menu, fromIndex: contentStartIndex, shapes: shapes, with: scratch) + self.cacheVisibleMergedSwitcherContent( + in: menu, + selection: context.switcherSelection, + contentStartIndex: contentStartIndex, + menuWidth: context.menuWidth, + contentVersion: self.menuContentVersion) + } + } + + /// Adds everything below the provider switcher (account switchers, card content, and + /// actionable sections) to `target`, which may be a detached scratch menu; interaction + /// closures always capture `captureMenu`, the live menu the rows will serve. + private func addSwitcherScopedMenuContent( + into target: NSMenu, + captureMenu: NSMenu, + context: MenuUpdateContext) + { + self.addCodexAccountSwitcherIfNeeded( + to: target, + display: context.codexAccountDisplay, + width: context.menuWidth, + captureMenu: captureMenu) + self.lastCodexAccountMenuDisplay = context.codexAccountDisplay + self.addTokenAccountSwitcherIfNeeded( + to: target, + display: context.tokenAccountDisplay, + width: context.menuWidth, + captureMenu: captureMenu) + self.lastTokenAccountMenuDisplay = context.tokenAccountDisplay + + let menuContext = MenuCardContext( + currentProvider: context.currentProvider, + selectedProvider: context.provider, + menuWidth: context.menuWidth, + codexAccountDisplay: context.codexAccountDisplay, + tokenAccountDisplay: context.tokenAccountDisplay, + openAIContext: context.openAIContext) + self.addPrimaryMenuContent( + to: target, + context: menuContext, + switcherSelection: context.switcherSelection, + captureMenu: captureMenu) + self.addActionableSections( + context.descriptor.sections, + to: target, + width: context.menuWidth, + captureMenu: captureMenu) + } +} diff --git a/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift b/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift index b31c447c..5f323f10 100644 --- a/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift +++ b/Sources/CodexBar/StatusItemController+MergedSwitcherContentCache.swift @@ -65,6 +65,32 @@ extension StatusItemController { self.mergedSwitcherContentCaches[ObjectIdentifier(menu), default: [:]][selection] = entry } + /// Non-consuming variant of `addCachedMergedSwitcherContent`'s lookup: reports whether a + /// reusable entry exists (evicting it when stale) without attaching anything, so callers + /// can choose between reattaching cached content and recycling the outgoing views. + func hasReusableMergedSwitcherContent( + for selection: ProviderSwitcherSelection, + in menu: NSMenu, + menuWidth: CGFloat, + codexAccountDisplay: CodexAccountMenuDisplay?, + tokenAccountDisplay: TokenAccountMenuDisplay?) + -> Bool + { + let key = ObjectIdentifier(menu) + guard let entry = self.mergedSwitcherContentCaches[key]?[selection] else { return false } + guard entry.matches( + requiredMenuContentVersion: self.latestRequiredMenuRebuildVersion, + menuWidth: menuWidth, + codexAccountDisplay: codexAccountDisplay, + tokenAccountDisplay: tokenAccountDisplay, + localizationSignature: self.menuLocalizationSignature()) + else { + self.mergedSwitcherContentCaches[key]?.removeValue(forKey: selection) + return false + } + return true + } + func addCachedMergedSwitcherContent( for selection: ProviderSwitcherSelection, to menu: NSMenu, diff --git a/Sources/CodexBar/StatusItemController.swift b/Sources/CodexBar/StatusItemController.swift index 7d28152d..23208fcf 100644 --- a/Sources/CodexBar/StatusItemController.swift +++ b/Sources/CodexBar/StatusItemController.swift @@ -235,6 +235,10 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin var mergedSwitcherContentCaches: [ObjectIdentifier: [ProviderSwitcherSelection: CachedMergedSwitcherMenuContent]] = [:] var preservesMergedSwitcherContentCachesDuringInvalidation = false + /// Card hosting views harvested from items about to be discarded by the current populate + /// pass, keyed by card identifier; consumed by `makeMenuCardItem` and cleared when the + /// pass finishes. Never outlives a single synchronous menu population. + var menuCardViewRecyclePool: [String: NSView] = [:] /// Monotonic token used to ignore stale deferred provider-switcher menu rebuilds. var providerSwitcherUpdateToken = 0 var providerSelectionUIRefreshTask: Task? diff --git a/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift new file mode 100644 index 00000000..7c623bb6 --- /dev/null +++ b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift @@ -0,0 +1,449 @@ +import AppKit +import CodexBarCore +import SwiftUI +import Testing +@testable import CodexBar + +@MainActor +private final class RecordingMenuHighlightView: NSView, MenuCardHighlighting { + private(set) var isHighlighted = false + + func setHighlighted(_ highlighted: Bool) { + self.isHighlighted = highlighted + } +} + +extension StatusMenuTests { + private func makeRecyclingController(settings: SettingsStore) -> StatusItemController { + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + return StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + } + + private func cardViewIdentities(in menu: NSMenu) -> [String: ObjectIdentifier] { + var identities: [String: ObjectIdentifier] = [:] + for item in menu.items { + guard let id = item.representedObject as? String else { continue } + guard let view = item.view, view is any MenuCardMeasuring else { continue } + identities[id] = ObjectIdentifier(view) + } + return identities + } + + @Test + func `data only repopulate reuses menu card hosting views`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + let registry = ProviderRegistry.shared + for provider in UsageProvider.allCases { + if let metadata = registry.metadata[provider] { + settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex) + } + } + + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = controller.makeMenu() + controller.populateMenu(menu, provider: .codex) + let firstPass = self.cardViewIdentities(in: menu) + #expect(!firstPass.isEmpty) + + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + controller.populateMenu(menu, provider: .codex) + let secondPass = self.cardViewIdentities(in: menu) + + #expect(secondPass.keys.sorted() == firstPass.keys.sorted()) + for (id, identity) in firstPass { + #expect(secondPass[id] == identity, "card \(id) should reuse its hosting view") + } + #expect(controller.menuCardViewRecyclePool.isEmpty) + } + + @Test + func `merged data tick reconciles items in place without churn`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.mergedMenuLastSelectedWasOverview = false + let registry = ProviderRegistry.shared + let enabled: Set = [.codex, .claude] + for provider in UsageProvider.allCases { + if let metadata = registry.metadata[provider] { + settings.setProviderEnabled( + provider: provider, + metadata: metadata, + enabled: enabled.contains(provider)) + } + } + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + + controller.selectedMenuProvider = .codex + let menu = controller.makeMenu() + controller.populateMenu(menu, provider: .codex) + let itemsBefore = menu.items.map(ObjectIdentifier.init) + let cardViewsBefore = self.cardViewIdentities(in: menu) + #expect(!cardViewsBefore.isEmpty) + + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + controller.populateMenu(menu, provider: .codex) + + let itemsAfter = menu.items.map(ObjectIdentifier.init) + #expect(itemsAfter == itemsBefore, "data-only repopulate should not remove or insert menu items") + let cardViewsAfter = self.cardViewIdentities(in: menu) + for (id, identity) in cardViewsBefore { + #expect(cardViewsAfter[id] == identity, "card \(id) should reuse its hosting view") + } + } + + @Test + func `reconcile keeps matching edge rows when the middle differs`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + func plainItem(_ title: String) -> NSMenuItem { + NSMenuItem(title: title, action: nil, keyEquivalent: "") + } + + let menu = NSMenu() + menu.addItem(controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300)) + menu.addItem(.separator()) + menu.addItem(plainItem("Old Provider Action")) + menu.addItem(plainItem("Old Provider Detail")) + menu.addItem(.separator()) + menu.addItem(plainItem("Settings")) + let cardItem = menu.items[0] + let cardView = cardItem.view + let settingsItem = menu.items[5] + + let shapes = controller.menuContentShapes(in: menu, fromIndex: 0) + controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil) + defer { controller.clearMenuCardViewRecyclePool() } + + let scratch = NSMenu() + scratch.addItem(controller.makeMenuCardItem(Text("other provider card"), id: "menuCard", width: 300)) + scratch.addItem(.separator()) + scratch.addItem(plainItem("New Provider Action")) + scratch.addItem(.separator()) + scratch.addItem(plainItem("Settings")) + + controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch) + + #expect(menu.items.count == 5) + #expect(menu.items[0] === cardItem, "card row should be updated in place") + #expect(menu.items[0].view === cardView, "card hosting view should be recycled in place") + #expect(menu.items[4] === settingsItem, "shared trailing row should be updated in place") + #expect(menu.items[2].title == "New Provider Action") + } + + @Test + func `reconcile preserves highlight on a retained custom action row`() { + let settings = self.makeSettings() + settings.statusChecksEnabled = false + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let liveItem = NSMenuItem() + liveItem.isEnabled = true + liveItem.representedObject = "action" + liveItem.view = RecordingMenuHighlightView() + menu.addItem(liveItem) + controller.menu(menu, willHighlight: liveItem) + + let replacementView = RecordingMenuHighlightView() + let replacementItem = NSMenuItem() + replacementItem.isEnabled = true + replacementItem.representedObject = "action" + replacementItem.view = replacementView + let scratch = NSMenu() + scratch.addItem(replacementItem) + + let shapes = controller.menuContentShapes(in: menu, fromIndex: 0) + controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch) + + #expect(menu.items[0] === liveItem) + #expect(liveItem.view === replacementView) + #expect(replacementView.isHighlighted) + #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem) + } + + @Test + func `reconcile restores highlight on a retained recycled card`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let liveItem = controller.makeMenuCardItem(Text("before"), id: "menuCard", width: 300) + menu.addItem(liveItem) + controller.menu(menu, willHighlight: liveItem) + guard let hosting = liveItem.view as? MenuCardItemHostingView> + else { + Issue.record("expected a card hosting view") + return + } + + let shapes = controller.menuContentShapes(in: menu, fromIndex: 0) + controller.harvestRecyclableMenuCardViews( + in: menu, + fromIndex: 0, + displacedSelection: nil, + preserveHighlightedItem: true) + defer { controller.clearMenuCardViewRecyclePool() } + #expect(!hosting.highlightState.isHighlighted) + #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem) + + let scratch = NSMenu() + scratch.addItem(controller.makeMenuCardItem(Text("after"), id: "menuCard", width: 300)) + controller.reconcileMenuContent(menu, fromIndex: 0, shapes: shapes, with: scratch) + + #expect(menu.items[0] === liveItem) + #expect(liveItem.view === hosting) + #expect(hosting.highlightState.isHighlighted) + #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === liveItem) + } + + @Test + func `harvesting consumes only the displaced selection cache entry`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let item = controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300) + menu.addItem(item) + + let entry = CachedMergedSwitcherMenuContent( + requiredMenuContentVersion: 0, + menuWidth: 300, + codexAccountDisplay: nil, + tokenAccountDisplay: nil, + localizationSignature: "", + items: []) + controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [ + .overview: entry, + .provider(.codex): entry, + ] + controller.harvestRecyclableMenuCardViews( + in: menu, + fromIndex: 0, + displacedSelection: .provider(.codex)) + defer { controller.clearMenuCardViewRecyclePool() } + + #expect(controller.menuCardViewRecyclePool.count == 1) + #expect(item.view == nil) + let remaining = controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] + #expect(remaining?[.provider(.codex)] == nil) + #expect(remaining?[.overview] != nil) + } + + @Test + func `harvesting consumes displaced cache when card rendering is disabled`() { + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = false + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let entry = CachedMergedSwitcherMenuContent( + requiredMenuContentVersion: 0, + menuWidth: 300, + codexAccountDisplay: nil, + tokenAccountDisplay: nil, + localizationSignature: "", + items: []) + controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] = [ + .overview: entry, + .provider(.codex): entry, + ] + + controller.harvestRecyclableMenuCardViews( + in: menu, + fromIndex: 0, + displacedSelection: .provider(.codex)) + + let remaining = controller.mergedSwitcherContentCaches[ObjectIdentifier(menu)] + #expect(remaining?[.provider(.codex)] == nil) + #expect(remaining?[.overview] != nil) + } + + @Test + func `type compatible leftover is adopted across card identifiers`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let original = controller.makeMenuCardItem(Text("codex usage"), id: "menuCard-0", width: 300) + menu.addItem(original) + let originalView = original.view + + controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil) + defer { controller.clearMenuCardViewRecyclePool() } + let switched = controller.makeMenuCardItem(Text("claude usage"), id: "menuCard", width: 300) + + #expect(switched.view === originalView) + #expect(controller.menuCardViewRecyclePool.isEmpty) + } + + @Test + func `recycled card keeps its hosting view and highlight state`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let original = controller.makeMenuCardItem(Text("before"), id: "menuCard", width: 300) + menu.addItem(original) + guard let originalView = original.view as? MenuCardItemHostingView> + else { + Issue.record("expected a card hosting view") + return + } + + controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil) + defer { controller.clearMenuCardViewRecyclePool() } + let rebuilt = controller.makeMenuCardItem(Text("after"), id: "menuCard", width: 300) + + #expect(rebuilt.view === originalView) + guard let rebuiltView = rebuilt.view as? MenuCardItemHostingView> + else { + Issue.record("expected the recycled hosting view") + return + } + #expect(rebuiltView.highlightState === originalView.highlightState) + rebuiltView.setHighlighted(true) + #expect(rebuiltView.highlightState.isHighlighted) + rebuiltView.setHighlighted(false) + } + + @Test + func `harvesting a highlighted card clears its highlight and tracking entry`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let item = controller.makeMenuCardItem(Text("card"), id: "menuCard", width: 300) + menu.addItem(item) + controller.menu(menu, willHighlight: item) + guard let hosting = item.view as? MenuCardItemHostingView> + else { + Issue.record("expected a card hosting view") + return + } + #expect(hosting.highlightState.isHighlighted) + #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] === item) + + controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil) + defer { controller.clearMenuCardViewRecyclePool() } + + #expect(!hosting.highlightState.isHighlighted) + #expect(controller.highlightedMenuItems[ObjectIdentifier(menu)] == nil) + + let rebuilt = controller.makeMenuCardItem(Text("rebuilt"), id: "menuCard", width: 300) + #expect(rebuilt.view === hosting) + #expect(!hosting.highlightState.isHighlighted) + } + + @Test + func `same id with different content type builds a fresh view`() { + StatusItemController.setMenuRefreshEnabledForTesting(false) + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let original = controller.makeMenuCardItem(Text("text card"), id: "menuCard", width: 300) + menu.addItem(original) + let originalView = original.view + + controller.harvestRecyclableMenuCardViews(in: menu, fromIndex: 0, displacedSelection: nil) + defer { controller.clearMenuCardViewRecyclePool() } + let rebuilt = controller.makeMenuCardItem(Image(systemName: "clock"), id: "menuCard", width: 300) + + #expect(rebuilt.view != nil) + #expect(rebuilt.view !== originalView) + // The incompatible pool entry is consumed rather than left behind. + #expect(controller.menuCardViewRecyclePool.isEmpty) + } +} diff --git a/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift b/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift index a49fc7c1..c10999cb 100644 --- a/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift +++ b/Tests/CodexBarTests/StatusMenuSwitcherRefreshTests.swift @@ -156,7 +156,7 @@ struct StatusMenuSwitcherRefreshTests { } @Test - func `merged provider switch restores cached tab content`() async throws { + func `merged provider switch updates live tab rows in place`() async throws { let previousMenuCardRendering = StatusItemController.menuCardRenderingEnabled StatusItemController.menuCardRenderingEnabled = false StatusItemController.setMenuRefreshEnabledForTesting(true) @@ -198,12 +198,14 @@ struct StatusMenuSwitcherRefreshTests { } defer { controller._test_openMenuRebuildObserver = nil } + // Provider switches now reconcile matching rows in place instead of parking and + // restoring distinct item sets per tab: the same NSMenuItem objects carry each + // tab's freshly built content, so AppKit never relayouts the open menu per insert. let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView) #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag)) await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount }) #expect(menu.items.indices.contains(contentStartIndex)) - let alternateContentID = ObjectIdentifier(menu.items[contentStartIndex]) - #expect(alternateContentID != originalContentID) + #expect(ObjectIdentifier(menu.items[contentStartIndex]) == originalContentID) let alternateSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView) #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag)) @@ -215,7 +217,7 @@ struct StatusMenuSwitcherRefreshTests { #expect(restoredSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag)) await Self.waitForRebuildCount(3, rebuildCount: { rebuildCount }) #expect(menu.items.indices.contains(contentStartIndex)) - #expect(ObjectIdentifier(menu.items[contentStartIndex]) == alternateContentID) + #expect(ObjectIdentifier(menu.items[contentStartIndex]) == originalContentID) controller.invalidateMenus() #expect(controller.mergedSwitcherContentCaches.isEmpty) @@ -253,9 +255,7 @@ struct StatusMenuSwitcherRefreshTests { let menu = controller.makeMenu() controller.menuWillOpen(menu) let contentStartIndex = controller.providerSwitcherContentStartIndex(in: menu) - let originalContent = try #require( - menu.items.indices.contains(contentStartIndex) ? menu.items[contentStartIndex] : nil) - let originalContentID = ObjectIdentifier(originalContent) + #expect(menu.items.indices.contains(contentStartIndex)) let selectedButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .on }) let alternateButton = try #require(Self.switcherButtons(in: menu).first { $0.state == .off }) @@ -266,6 +266,7 @@ struct StatusMenuSwitcherRefreshTests { defer { controller._test_openMenuRebuildObserver = nil } controller.invalidateMenus() + #expect(controller.mergedSwitcherContentCaches.isEmpty) let initialSwitcher = try #require(menu.items.first?.view as? ProviderSwitcherView) #expect(initialSwitcher._test_simulateRuntimeClick(buttonTag: alternateButton.tag)) await Self.waitForRebuildCount(1, rebuildCount: { rebuildCount }) @@ -274,8 +275,17 @@ struct StatusMenuSwitcherRefreshTests { #expect(alternateSwitcher._test_simulateRuntimeClick(buttonTag: selectedButton.tag)) await Self.waitForRebuildCount(2, rebuildCount: { rebuildCount }) + // Rows are reconciled in place, so freshness is guaranteed by rebuilding content + // from current data rather than by minting new items: the live menu must be marked + // fresh and no cached entry may predate the required invalidation. (In-place item + // identity itself is covered deterministically in MenuCardViewRecyclingTests; here + // async gate state may legitimately route a populate through the full rebuild.) #expect(menu.items.indices.contains(contentStartIndex)) - #expect(ObjectIdentifier(menu.items[contentStartIndex]) != originalContentID) + let menuKey = ObjectIdentifier(menu) + #expect(controller.menuVersions[menuKey] == controller.menuContentVersion) + for entry in controller.mergedSwitcherContentCaches[menuKey]?.values ?? [:].values { + #expect(entry.requiredMenuContentVersion >= controller.latestRequiredMenuRebuildVersion) + } } @Test From 3c2d53de57c118149b8511abb333aebb01cdf327 Mon Sep 17 00:00:00 2001 From: Joshua Vial Date: Thu, 11 Jun 2026 06:49:04 +0800 Subject: [PATCH 26/51] Fix menu open refresh delay (#1398) * Fix menu open refresh delay * docs: note instant cached menu opening --------- Co-authored-by: Peter Steinberger --- CHANGELOG.md | 1 + Sources/CodexBar/MenuCardView.swift | 2 +- .../Kilo/UsageStore+KiloOrgRefresh.swift | 3 +- .../StatusItemController+Actions.swift | 3 +- .../CodexBar/StatusItemController+Menu.swift | 55 +- .../StatusItemController+MenuCardModel.swift | 2 +- ...temController+MenuInteractionRefresh.swift | 14 +- ...ItemController+MenuRefreshScheduling.swift | 5 + .../StatusItemController+MenuTracking.swift | 125 +- Sources/CodexBar/StatusItemController.swift | 13 +- .../CodexBar/UsageStore+PlanUtilization.swift | 5 + Sources/CodexBar/UsageStore+Refresh.swift | 213 ++- .../CodexBar/UsageStore+TokenAccounts.swift | 53 +- Sources/CodexBar/UsageStore.swift | 18 +- Sources/CodexBar/UsageStoreSupport.swift | 72 + .../CodexBarTests/MenuCardSubtitleTests.swift | 45 + .../StatusMenuClosedPreparationTests.swift | 8 + .../StatusMenuInstantOpenTests.swift | 1540 +++++++++++++++++ .../StatusMenuOpenRefreshTests.swift | 125 +- Tests/CodexBarTests/StatusMenuTests.swift | 13 +- .../StatusMenuTokenAccountSwitcherTests.swift | 7 +- 21 files changed, 2145 insertions(+), 177 deletions(-) create mode 100644 Tests/CodexBarTests/StatusMenuInstantOpenTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index 80e3f436..c7636ecd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ - Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra! - Menu bar: defer pasteboard writes and copy feedback outside the `NSMenu` tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405! - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). +- Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! - Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl! - Development: disable Keychain access for unbundled executables to avoid repeated password prompts while preserving packaged app behavior (#1271). Thanks @Yuxin-Qiao! - Antigravity: exclude model quotas without a remaining fraction from family summaries so they no longer mask tracked usage in the automatic menu-bar metric (#1369). Thanks @Martin-Hausleitner! diff --git a/Sources/CodexBar/MenuCardView.swift b/Sources/CodexBar/MenuCardView.swift index 89c3d220..1c3532da 100644 --- a/Sources/CodexBar/MenuCardView.swift +++ b/Sources/CodexBar/MenuCardView.swift @@ -1047,7 +1047,7 @@ extension UsageMenuCardView.Model { return (lastError.trimmingCharacters(in: .whitespacesAndNewlines), .error) } - if isRefreshing, snapshot == nil { + if isRefreshing { return ("\(L("Refreshing"))…", .loading) } diff --git a/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift b/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift index ed1f7129..59e76dc7 100644 --- a/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift +++ b/Sources/CodexBar/Providers/Kilo/UsageStore+KiloOrgRefresh.swift @@ -35,7 +35,7 @@ extension UsageStore { self.kiloEnabledScopes.count > 1 } - func refreshKiloScopes() async { + func refreshKiloScopes(generation: UInt64? = nil) async { let scopes = self.kiloEnabledScopes guard scopes.count > 1 else { await MainActor.run { self.kiloScopeSnapshots = [] } @@ -102,6 +102,7 @@ extension UsageStore { let ordered = scopes.compactMap { resultByID[$0.scopeIdentifier] } await MainActor.run { + guard self.isCurrentProviderRefreshGeneration(.kilo, generation: generation) else { return } self.kiloScopeSnapshots = ordered } } diff --git a/Sources/CodexBar/StatusItemController+Actions.swift b/Sources/CodexBar/StatusItemController+Actions.swift index 9ce0d39d..d0607c57 100644 --- a/Sources/CodexBar/StatusItemController+Actions.swift +++ b/Sources/CodexBar/StatusItemController+Actions.swift @@ -44,8 +44,7 @@ extension StatusItemController: StatusItemMenuPersistentActionDelegate { func refreshOpenMenusAfterExplicitStoreAction() { self.invalidateMenus( refreshOpenMenus: true, - deferOpenParentMenuRebuild: true, - allowStaleContentDuringDataRefresh: true) + deferOpenParentMenuRebuild: true) } @objc func refreshNow() { diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift index 4740f033..9dfebcf3 100644 --- a/Sources/CodexBar/StatusItemController+Menu.swift +++ b/Sources/CodexBar/StatusItemController+Menu.swift @@ -1135,8 +1135,11 @@ extension StatusItemController { // provider fetch failed and needs a retry; periodic freshness is handled by the refresh timer. // AppKit menu tracking is modal, so starting provider refreshes while it is active can make the menu // feel frozen and can block keyboard focus from returning. - if self.menuNeedsDelayedRefreshRetry(for: menu) { - self.deferMenuInteractionRefreshIfNeeded() + let providersNeedingRetry = self.delayedRefreshRetryProviders(for: menu).filter { + self.store.isStale(provider: $0) || self.store.snapshot(for: $0) == nil + } + if !providersNeedingRetry.isEmpty { + self.deferMenuInteractionRefreshIfNeeded(providers: providersNeedingRetry) } let key = ObjectIdentifier(menu) self.menuRefreshTasks[key]?.cancel() @@ -1149,13 +1152,43 @@ extension StatusItemController { self.onDelayedMenuRefreshAttemptForTesting?() #endif guard self.openMenus[ObjectIdentifier(menu)] != nil else { return } - guard !self.store.isRefreshing else { return } - let retryProviders = self.delayedRefreshRetryProviders(for: menu) - let retryStaleProviderCount = retryProviders.count { self.store.isStale(provider: $0) } - let retryMissingSnapshotCount = retryProviders.count { self.store.snapshot(for: $0) == nil } - let willRetryRefresh = retryStaleProviderCount > 0 || retryMissingSnapshotCount > 0 - guard willRetryRefresh else { return } - self.deferMenuInteractionRefreshIfNeeded() + let availableProviders = Set(self.store.enabledProvidersForBackgroundWork()) + let retryProviders = self.delayedRefreshRetryProviders(for: menu).filter { + availableProviders.contains($0) && + (self.store.refreshingProviders.contains($0) || + self.store.isStale(provider: $0) || + self.store.snapshot(for: $0) == nil) + } + guard !retryProviders.isEmpty else { + self.clearSatisfiedDeferredMenuInteractionRefreshes( + for: self.delayedRefreshRetryProviders(for: menu)) + if self.menuNeedsRefresh(menu) { + self.scheduleOpenMenuRebuildIfStillVisible( + menu, + provider: self.menuProvider(for: menu), + resyncReadinessBaselineAfterRebuild: self.openMenus.count == 1) + } + return + } + self.deferMenuInteractionRefreshIfNeeded(providers: retryProviders) + await ProviderInteractionContext.$current.withValue(.background) { + for provider in retryProviders { + guard !Task.isCancelled else { return } + await self.store.refreshProvider(provider, coalesceIfRefreshing: true) + } + } + let stillNeedsRetry = retryProviders.contains { + self.store.isStale(provider: $0) || self.store.snapshot(for: $0) == nil + } + if !stillNeedsRetry { + self.clearSatisfiedDeferredMenuInteractionRefreshes(for: retryProviders) + } + guard !Task.isCancelled else { return } + guard self.openMenus[ObjectIdentifier(menu)] != nil else { return } + self.invalidateMenus( + refreshOpenMenus: true, + deferOpenParentMenuRebuild: false, + allowStaleContentDuringDataRefresh: true) } } @@ -1168,6 +1201,10 @@ extension StatusItemController { } private func delayedRefreshRetryProviders(for menu: NSMenu) -> [UsageProvider] { + self.renderedProviders(for: menu) + } + + func renderedProviders(for menu: NSMenu) -> [UsageProvider] { let enabledProviders = self.store.enabledProvidersForDisplay() guard !enabledProviders.isEmpty else { return [] } let includesOverview = self.includesOverviewTab(enabledProviders: enabledProviders) diff --git a/Sources/CodexBar/StatusItemController+MenuCardModel.swift b/Sources/CodexBar/StatusItemController+MenuCardModel.swift index 7c17a655..eebc4b83 100644 --- a/Sources/CodexBar/StatusItemController+MenuCardModel.swift +++ b/Sources/CodexBar/StatusItemController+MenuCardModel.swift @@ -101,7 +101,7 @@ extension StatusItemController { tokenSnapshot: tokenSnapshot, tokenError: tokenError, account: fallbackAccount, - isRefreshing: self.store.shouldShowRefreshingMenuCard(for: target), + isRefreshing: self.store.shouldShowRefreshingMenuCardIndicator(for: target), lastError: errorOverride ?? codexProjection?.userFacingErrors.usage ?? self.store.userFacingError(for: target), diff --git a/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift b/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift index 6c27e636..5cfcf765 100644 --- a/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift +++ b/Sources/CodexBar/StatusItemController+MenuInteractionRefresh.swift @@ -58,9 +58,17 @@ extension StatusItemController { ]) } - func deferMenuInteractionRefreshIfNeeded() { + func deferMenuInteractionRefreshIfNeeded(providers: [UsageProvider]) { guard !self.store.isRefreshing else { return } - self.deferredMenuInteractionRefreshPending = true + self.deferredMenuInteractionRefreshProviders.formUnion(providers) + } + + func clearSatisfiedDeferredMenuInteractionRefreshes(for providers: [UsageProvider]) { + for provider in providers + where !self.store.isStale(provider: provider) && self.store.snapshot(for: provider) != nil + { + self.deferredMenuInteractionRefreshProviders.remove(provider) + } } func deferOpenAIDashboardRefreshUntilMenuCloses(reason: String) { @@ -110,7 +118,7 @@ extension StatusItemController { return } self.deferredMenuInteractionRefreshTask = nil - self.deferredMenuInteractionRefreshPending = false + self.deferredMenuInteractionRefreshProviders.removeAll() self.deferredOpenAIDashboardRefreshReason = nil #if DEBUG self.onDeferredMenuInteractionRefreshForTesting?() diff --git a/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift b/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift index 4980a019..a6b21ed3 100644 --- a/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift +++ b/Sources/CodexBar/StatusItemController+MenuRefreshScheduling.swift @@ -120,6 +120,7 @@ extension StatusItemController { [ provider.rawValue, "token=\(tokenSignature)", + "refreshing=\(self.store.shouldShowRefreshingMenuCardIndicator(for: provider) ? "1" : "0")", "usageHistory=\(usageHistoryVisible ? "1" : "0")", ].joined(separator: ":")) } @@ -214,6 +215,7 @@ extension StatusItemController { _ menu: NSMenu, provider: UsageProvider?, closeHostedSubviewMenusBeforeRebuild: Bool = false, + resyncReadinessBaselineAfterRebuild: Bool = false, debounceNanoseconds: UInt64 = 0, beforeRebuild: (@MainActor () -> Bool)? = nil) { @@ -255,6 +257,9 @@ extension StatusItemController { self.closeHostedSubviewMenusForParentSwitch() } self.rebuildOpenMenuIfStillVisible(menu, provider: provider) + if resyncReadinessBaselineAfterRebuild, !self.menuNeedsRefresh(menu) { + self.resyncMenuAdjunctReadinessBaseline() + } } } diff --git a/Sources/CodexBar/StatusItemController+MenuTracking.swift b/Sources/CodexBar/StatusItemController+MenuTracking.swift index 9d437f01..037edcdd 100644 --- a/Sources/CodexBar/StatusItemController+MenuTracking.swift +++ b/Sources/CodexBar/StatusItemController+MenuTracking.swift @@ -37,6 +37,11 @@ extension StatusItemController { self.clearMergedSwitcherContentCaches() } self.pruneVersionScopedMenuCardHeightCache() + if allowStaleContentDuringDataRefresh { + self.latestDataOnlyMenuContentVersion = self.menuContentVersion + } else { + self.latestStructuralMenuContentVersion = self.menuContentVersion + } if !allowStaleContentDuringDataRefresh, !preservesMergedSwitcherContentCaches { self.latestRequiredMenuRebuildVersion = self.menuContentVersion } @@ -49,31 +54,56 @@ extension StatusItemController { deferParentRebuildDuringTracking: deferOpenParentMenuRebuild) return } + if allowStaleContentDuringDataRefresh { + if !self.cancelNonRequiredClosedMenuPreparation() { + self.prepareAttachedClosedMenusIfNeeded() + } + return + } self.prepareAttachedClosedMenusIfNeeded() } + @discardableResult + private func cancelNonRequiredClosedMenuPreparation() -> Bool { + let menus = self.attachedMenusForClosedPreparation() + let hasRequiredClosedMenu = self.latestRequiredMenuRebuildVersion > 0 && menus.contains { menu in + let key = ObjectIdentifier(menu) + return (self.menuVersions[key] ?? -1) < self.latestRequiredMenuRebuildVersion + } + guard !hasRequiredClosedMenu else { return false } + self.cancelAllClosedMenuRebuilds() + for menu in menus { + self.closedMenusDeferredUntilNextOpen.remove(ObjectIdentifier(menu)) + } + return true + } + func prepareAttachedClosedMenusIfNeeded() { guard self.isMenuRefreshEnabled else { return } guard self.openMenus.isEmpty else { return } guard !self.isMenuDataRefreshInFlight else { return } let menus = self.attachedMenusForClosedPreparation() let requiredClosedPreparationVersion: Int? - if self.menuContentVersion > self.latestRequiredMenuRebuildVersion { - guard self.latestRequiredMenuRebuildVersion > 0 else { return } - let hasRequiredClosedMenu = menus.contains { menu in - let key = ObjectIdentifier(menu) - return (self.menuVersions[key] ?? -1) < self.latestRequiredMenuRebuildVersion - } - guard hasRequiredClosedMenu else { return } + if self.latestRequiredMenuRebuildVersion > 0, + menus.contains(where: { menu in + let key = ObjectIdentifier(menu) + return (self.menuVersions[key] ?? -1) < self.latestRequiredMenuRebuildVersion + }) + { requiredClosedPreparationVersion = self.latestRequiredMenuRebuildVersion + } else if self.menuContentVersion > self.latestRequiredMenuRebuildVersion { + guard self.latestRequiredMenuRebuildVersion > 0 else { return } + return } else { requiredClosedPreparationVersion = nil } for menu in menus { let key = ObjectIdentifier(menu) - guard !self.closedMenusDeferredUntilNextOpen.contains(key) else { continue } if let requiredClosedPreparationVersion { + self.closedMenusDeferredUntilNextOpen.remove(key) guard (self.menuVersions[key] ?? -1) < requiredClosedPreparationVersion else { continue } + } else { + guard !self.closedMenusDeferredUntilNextOpen.contains(key) else { continue } } // Pre-warming the merged menu while it is closed runs a full main-thread populateMenu // (incl. SwiftUI hosting-view layout) that menuWillOpen redoes synchronously on display @@ -96,6 +126,7 @@ extension StatusItemController { self.menuProviders.removeValue(forKey: key) self.menuVersions.removeValue(forKey: key) self.menuReadinessSignatures.removeValue(forKey: key) + self.menuIdentitySignatures.removeValue(forKey: key) self.closedMenusDeferredUntilNextOpen.remove(key) } @@ -112,28 +143,36 @@ extension StatusItemController { func refreshMenuForOpenIfNeeded(_ menu: NSMenu, provider: UsageProvider?) { self.closedMenusDeferredUntilNextOpen.remove(ObjectIdentifier(menu)) guard self.menuNeedsRefresh(menu) else { return } - if self.canPreserveStaleMenuContentDuringRefresh(menu) { + if self.canPreserveStaleMenuContentForInstantOpen(menu) { #if DEBUG self.menuLogger.debug( - "menu open kept existing content during refresh", + "menu open kept existing content for instant render", metadata: [ "items": "\(menu.items.count)", "provider": provider?.rawValue ?? "nil", "storeRefreshing": self.store.isRefreshing ? "1" : "0", ]) #endif - self.deferMenuInteractionRefreshIfNeeded() + if self.isMenuRefreshEnabled, !self.isMenuDataRefreshInFlight { + self.scheduleOpenMenuRebuildIfStillVisible( + menu, + provider: provider, + resyncReadinessBaselineAfterRebuild: self.openMenus.isEmpty) + } return } self.populateMenu(menu, provider: provider) self.markMenuFresh(menu) } - private func canPreserveStaleMenuContentDuringRefresh(_ menu: NSMenu) -> Bool { - guard self.isMenuDataRefreshInFlight, !menu.items.isEmpty else { return false } + private func canPreserveStaleMenuContentForInstantOpen(_ menu: NSMenu) -> Bool { + guard !menu.items.isEmpty else { return false } let key = ObjectIdentifier(menu) guard let menuVersion = self.menuVersions[key] else { return false } - return menuVersion >= self.latestRequiredMenuRebuildVersion + return self.menuContentVersion == self.latestDataOnlyMenuContentVersion && + menuVersion >= self.latestStructuralMenuContentVersion && + self.menuIdentitySignatures[key] == self.menuIdentitySignature( + for: self.renderedProviders(for: menu)) } private func attachedMenusForClosedPreparation() -> [NSMenu] { @@ -233,6 +272,64 @@ extension StatusItemController { let key = ObjectIdentifier(menu) self.menuVersions[key] = self.menuContentVersion self.menuReadinessSignatures[key] = self.menuAdjunctReadinessSignature() + self.menuIdentitySignatures[key] = self.menuIdentitySignature( + for: self.renderedProviders(for: menu)) + } + + private func menuIdentitySignature(for providers: [UsageProvider]) -> String { + var parts: [String] = [] + for target in providers { + parts.append(target.rawValue) + parts.append(self.providerIdentitySignature(self.store.snapshot(for: target)?.identity(for: target))) + + if self.store.metadata(for: target).usesAccountFallback { + let account = self.store.accountInfo(for: target) + parts.append(Self.menuIdentityField(account.email)) + parts.append(Self.menuIdentityField(account.plan)) + } + + for accountSnapshot in self.store.accountSnapshots[target] ?? [] { + parts.append(accountSnapshot.account.id.uuidString) + parts.append(Self.menuIdentityField(accountSnapshot.account.label)) + parts.append(self.providerIdentitySignature(accountSnapshot.snapshot?.identity(for: target))) + } + + if target == .codex { + for account in self.settings.codexVisibleAccountProjection.visibleAccounts { + parts.append(Self.menuIdentityField(account.id)) + parts.append(Self.menuIdentityField(account.email)) + parts.append(Self.menuIdentityField(account.workspaceLabel)) + parts.append(account.isActive ? "active" : "inactive") + parts.append(account.isLive ? "live" : "stored") + } + for accountSnapshot in self.store.codexAccountSnapshots { + parts.append(Self.menuIdentityField(accountSnapshot.id)) + parts.append(self.providerIdentitySignature(accountSnapshot.snapshot?.identity(for: target))) + } + } + + if target == .kilo { + for scopeSnapshot in self.store.kiloScopeSnapshots { + parts.append(Self.menuIdentityField(scopeSnapshot.id)) + parts.append(self.providerIdentitySignature(scopeSnapshot.snapshot?.identity(for: target))) + } + } + } + return parts.joined(separator: "|") + } + + private func providerIdentitySignature(_ identity: ProviderIdentitySnapshot?) -> String { + [ + identity?.providerID?.rawValue ?? "", + Self.menuIdentityField(identity?.accountEmail), + Self.menuIdentityField(identity?.accountOrganization), + Self.menuIdentityField(identity?.loginMethod), + ].joined(separator: ":") + } + + private static func menuIdentityField(_ value: String?) -> String { + let value = value ?? "" + return "\(value.utf8.count):\(value)" } func hasOpenHostedSubviewMenu() -> Bool { diff --git a/Sources/CodexBar/StatusItemController.swift b/Sources/CodexBar/StatusItemController.swift index 23208fcf..b1e57e6e 100644 --- a/Sources/CodexBar/StatusItemController.swift +++ b/Sources/CodexBar/StatusItemController.swift @@ -116,6 +116,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin var menuProviders: [ObjectIdentifier: UsageProvider] = [:] var menuContentVersion: Int = 0 var latestRequiredMenuRebuildVersion: Int = 0 + var latestDataOnlyMenuContentVersion: Int = 0 + var latestStructuralMenuContentVersion: Int = 0 var menuVersions: [ObjectIdentifier: Int] = [:] var menuReadinessSignatures: [ObjectIdentifier: String] = [:] let hostedSubviewRenderSignatures = NSMapTable.weakToStrongObjects() @@ -136,9 +138,14 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin var openMenuRebuildTasks: [ObjectIdentifier: Task] = [:] var openMenuRebuildTokens: [ObjectIdentifier: Int] = [:] var openMenuRebuildTokenCounter = 0 + var menuIdentitySignatures: [ObjectIdentifier: String] = [:] var openMenuRebuildsClosingHostedSubviewMenus: Set = [] var parentMenuRebuildsDeferredDuringTracking: Set = [] - var deferredMenuInteractionRefreshPending = false + var deferredMenuInteractionRefreshProviders: Set = [] + var deferredMenuInteractionRefreshPending: Bool { + !self.deferredMenuInteractionRefreshProviders.isEmpty + } + var deferredOpenAIDashboardRefreshReason: String? var deferredMenuInteractionRefreshTask: Task? var highlightedMenuItems: [ObjectIdentifier: NSMenuItem] = [:] @@ -649,6 +656,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin #endif let configChanged = self.settings.configRevision != self.lastConfigRevision let orderChanged = self.settings.providerOrder != self.lastProviderOrder + let localizationChanged = self.menuLocalizationSignature() != self.lastMenuLocalizationSignature let shouldRefreshOpenMenus = self.shouldRefreshOpenMenusForProviderSwitcher() self.invalidateMenus() if orderChanged || configChanged { @@ -657,7 +665,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin self.updateVisibility() self.updateIcons() if shouldRefreshOpenMenus { - self.refreshOpenMenusForStructureChange() + self.refreshOpenMenusAllowingParentRebuild( + deferParentRebuildDuringTracking: !localizationChanged) } } diff --git a/Sources/CodexBar/UsageStore+PlanUtilization.swift b/Sources/CodexBar/UsageStore+PlanUtilization.swift index 29406373..988e2525 100644 --- a/Sources/CodexBar/UsageStore+PlanUtilization.swift +++ b/Sources/CodexBar/UsageStore+PlanUtilization.swift @@ -94,6 +94,11 @@ extension UsageStore { && self.error(for: provider) == nil } + func shouldShowRefreshingMenuCardIndicator(for provider: UsageProvider) -> Bool { + let isRefreshing = self.isRefreshing || self.refreshingProviders.contains(provider) + return isRefreshing && self.error(for: provider) == nil + } + func shouldHidePlanUtilizationMenuItem(for provider: UsageProvider) -> Bool { guard self.supportsPlanUtilizationHistory(for: provider) else { return true } return self.shouldShowRefreshingMenuCard(for: provider) diff --git a/Sources/CodexBar/UsageStore+Refresh.swift b/Sources/CodexBar/UsageStore+Refresh.swift index eabe08c7..ed33360c 100644 --- a/Sources/CodexBar/UsageStore+Refresh.swift +++ b/Sources/CodexBar/UsageStore+Refresh.swift @@ -2,6 +2,19 @@ import CodexBarCore import Foundation extension UsageStore { + private struct ProviderRefreshOutcomeContext { + let generation: UInt64 + let codexExpectedGuard: CodexAccountScopedRefreshGuard? + let claudeCredentialsChanged: Bool + let shouldConsumeClaudeKeychainFingerprint: Bool + } + + func refreshForSettingsChange() async { + await self.runRefresh( + startupConnectivityRetryAttempt: nil, + coalesceProviderRefreshesOverride: false) + } + func prepareRefreshState(for provider: UsageProvider? = nil) { guard provider == nil || provider == .codex else { return } _ = self.settings.persistResolvedCodexActiveSourceCorrectionIfNeeded() @@ -20,9 +33,140 @@ extension UsageStore { return self.providerSpecs[provider] } - func refreshProvider(_ provider: UsageProvider, allowDisabled: Bool = false) async { + func refreshProvider( + _ provider: UsageProvider, + allowDisabled: Bool = false, + coalesceIfRefreshing: Bool = false) async + { + while coalesceIfRefreshing, + let states = self.providerRefreshTasks[provider], + let latestGeneration = self.latestProviderRefreshGenerations[provider], + let existingState = states.last(where: { $0.generation == latestGeneration }) + { + await self.waitForProviderRefresh(provider, state: existingState) + if Task.isCancelled { return } + if existingState.shouldRetry { + self.removeProviderRefreshTask(provider, state: existingState) + continue + } + return + } + + self.providerRefreshTaskGeneration &+= 1 + let generation = self.providerRefreshTaskGeneration + let predecessorStates = self.providerRefreshTasks[provider] ?? [] + for predecessorState in predecessorStates { + predecessorState.cancelTask() + } + self.latestProviderRefreshGenerations[provider] = generation + let state = ProviderRefreshTaskState(generation: generation) + let task = Task { @MainActor [weak self] in + guard let self else { return } + var snapshotUpdatedAtBeforeRefresh: Date? + var didStartRefresh = false + for predecessorState in predecessorStates { + await predecessorState.waitForTaskCompletion() + } + if !Task.isCancelled, self.isCurrentProviderRefreshGeneration(provider, generation: generation) { + snapshotUpdatedAtBeforeRefresh = self.snapshot(for: provider)?.updatedAt + didStartRefresh = true + await self.refreshProviderTracked( + provider, + allowDisabled: allowDisabled, + generation: generation) + } + let publishedNewSnapshot = didStartRefresh && + self.snapshot(for: provider)?.updatedAt != snapshotUpdatedAtBeforeRefresh + let retryRequired = Task.isCancelled && !publishedNewSnapshot + self.providerRefreshDidComplete(provider, state: state, retryRequired: retryRequired) + } + state.install(task: task) + self.providerRefreshTasks[provider, default: []].append(state) + await self.waitForProviderRefresh(provider, state: state) + } + + private func waitForProviderRefresh(_ provider: UsageProvider, state: ProviderRefreshTaskState) async { + self.providerRefreshWaiterGeneration &+= 1 + let waiterID = self.providerRefreshWaiterGeneration + guard let task = state.addWaiter(waiterID) else { return } + await withTaskCancellationHandler { + await task.value + } onCancel: { + state.cancelWaiter(waiterID) + } + state.finishWaiter(waiterID) + if state.canRemove { + self.scheduleProviderRefreshTaskRemoval(provider, state: state) + } + } + + private func providerRefreshDidComplete( + _ provider: UsageProvider, + state: ProviderRefreshTaskState, + retryRequired: Bool) + { + state.markCompleted(retryRequired: retryRequired) + self.scheduleProviderRefreshTaskRemoval(provider, state: state) + } + + private func removeProviderRefreshTask(_ provider: UsageProvider, state: ProviderRefreshTaskState) { + guard var states = self.providerRefreshTasks[provider] else { return } + states.removeAll { $0 === state } + if states.isEmpty { + self.providerRefreshTasks.removeValue(forKey: provider) + } else { + self.providerRefreshTasks[provider] = states + } + } + + private func scheduleProviderRefreshTaskRemoval(_ provider: UsageProvider, state: ProviderRefreshTaskState) { + Task { @MainActor [weak self] in + await Task.yield() + guard let self, + self.providerRefreshTasks[provider]?.contains(where: { $0 === state }) == true, + state.canRemove + else { + return + } + self.removeProviderRefreshTask(provider, state: state) + } + } + + func isCurrentProviderRefreshGeneration(_ provider: UsageProvider, generation: UInt64?) -> Bool { + guard let generation else { return true } + return self.latestProviderRefreshGenerations[provider] == generation + } + + private func refreshProviderTracked( + _ provider: UsageProvider, + allowDisabled: Bool, + generation: UInt64) async + { + self.providerRefreshCounts[provider, default: 0] += 1 + self.refreshingProviders.insert(provider) + defer { + let remaining = max(0, self.providerRefreshCounts[provider, default: 1] - 1) + if remaining == 0 { + self.providerRefreshCounts.removeValue(forKey: provider) + self.refreshingProviders.remove(provider) + } else { + self.providerRefreshCounts[provider] = remaining + } + } + await self.refreshProviderNow( + provider, + allowDisabled: allowDisabled, + generation: generation) + } + + private func refreshProviderNow( + _ provider: UsageProvider, + allowDisabled: Bool, + generation: UInt64) async + { self.prepareRefreshState(for: provider) guard let spec = await self.providerRefreshSpec(provider) else { return } + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } let codexExpectedGuard = provider == .codex ? self.freshCodexAccountScopedRefreshGuard() : nil if !spec.isEnabled(), !allowDisabled { @@ -30,18 +174,16 @@ extension UsageStore { return } - self.refreshingProviders.insert(provider) - defer { self.refreshingProviders.remove(provider) } - if provider == .codex, self.shouldFetchAllCodexVisibleAccounts() { - await self.refreshCodexVisibleAccountsForMenu() + await self.refreshCodexVisibleAccountsForMenu(generation: generation) return } else if provider == .codex { self.codexAccountSnapshots = [] } if provider == .kilo, self.shouldFanOutKiloScopes() { - await self.refreshKiloScopes() + await self.refreshKiloScopes(generation: generation) + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } // Continue to also fetch the personal snapshot through the regular path // so the existing single-card render keeps working when only personal is shown. // The presence of multi-element kiloScopeSnapshots triggers stacked rendering. @@ -51,7 +193,10 @@ extension UsageStore { let tokenAccounts = self.tokenAccounts(for: provider) if self.shouldFetchAllTokenAccounts(provider: provider, accounts: tokenAccounts) { - await self.refreshTokenAccounts(provider: provider, accounts: tokenAccounts) + await self.refreshTokenAccounts( + provider: provider, + accounts: tokenAccounts, + generation: generation) return } else { _ = await MainActor.run { @@ -62,7 +207,7 @@ extension UsageStore { let claudeAuthStateBeforeFetch = provider == .claude ? await Self.captureClaudeRefreshAuthState(invalidateCredentialsFile: true) : nil - let fetchContext = spec.makeFetchContext() + let fetchContext = self.makeFetchContext(provider: provider, override: nil) let descriptor = spec.descriptor // Keep provider fetch work off MainActor so slow keychain/process reads don't stall menu/UI responsiveness. let outcome = await withTaskGroup( @@ -74,6 +219,7 @@ extension UsageStore { } return await group.next()! } + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } let claudeAuthFingerprintAfterFetch = provider == .claude ? await Self.captureClaudeAuthFingerprintToken() : nil @@ -88,6 +234,22 @@ extension UsageStore { let shouldConsumeClaudeKeychainFingerprint = Self.shouldConsumeClaudeKeychainFingerprintChange( beforeFetch: claudeAuthStateBeforeFetch, changedDuringFetch: claudeAuthChangedDuringFetch) + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } + await self.applyProviderRefreshOutcome( + provider: provider, + outcome: outcome, + context: ProviderRefreshOutcomeContext( + generation: generation, + codexExpectedGuard: codexExpectedGuard, + claudeCredentialsChanged: claudeCredentialsChanged, + shouldConsumeClaudeKeychainFingerprint: shouldConsumeClaudeKeychainFingerprint)) + } + + private func applyProviderRefreshOutcome( + provider: UsageProvider, + outcome: ProviderFetchOutcome, + context: ProviderRefreshOutcomeContext) async + { await MainActor.run { self.lastFetchAttempts[provider] = outcome.attempts } @@ -96,17 +258,20 @@ extension UsageStore { case let .success(result): let scoped = result.usage.scoped(to: provider) if provider == .codex, - let codexExpectedGuard, + let codexExpectedGuard = context.codexExpectedGuard, !self.shouldApplyCodexUsageResult(expectedGuard: codexExpectedGuard, usage: scoped) { return } - let backfilled = await MainActor.run { - if claudeCredentialsChanged { + let backfilled = await MainActor.run { () -> UsageSnapshot? in + guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else { + return nil + } + if context.claudeCredentialsChanged { self.clearClaudeCredentialDerivedStateForCredentialSwapNow() } let resetBackfillSource = provider == .codex - ? self.codexLastKnownResetSnapshot(matching: codexExpectedGuard) + ? self.codexLastKnownResetSnapshot(matching: context.codexExpectedGuard) : self.lastKnownResetSnapshots[provider] let backfilled = scoped.backfillingResetTimes(from: resetBackfillSource) self.handleQuotaWarningTransitions(provider: provider, snapshot: backfilled) @@ -130,12 +295,14 @@ extension UsageStore { } return backfilled } - if shouldConsumeClaudeKeychainFingerprint { + guard let backfilled else { return } + if context.shouldConsumeClaudeKeychainFingerprint { _ = await Self.consumeClaudeKeychainFingerprintChangeWithoutPrompt() } await self.recordPlanUtilizationHistorySample( provider: provider, snapshot: backfilled) + guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else { return } if let runtime = self.providerRuntimes[provider] { let context = ProviderRuntimeContext( provider: provider, settings: self.settings, store: self) @@ -146,19 +313,23 @@ extension UsageStore { } case let .failure(error): if provider == .codex, - let codexExpectedGuard, + let codexExpectedGuard = context.codexExpectedGuard, !self.shouldApplyCodexScopedFailure(expectedGuard: codexExpectedGuard) { return } + guard self.isCurrentProviderRefreshGeneration(provider, generation: context.generation) else { return } self.recordStartupConnectivityRetryableFailure(error) - if claudeCredentialsChanged { + if context.claudeCredentialsChanged { await self.clearClaudeCredentialDerivedStateForCredentialSwap() } - if shouldConsumeClaudeKeychainFingerprint { + if context.shouldConsumeClaudeKeychainFingerprint { _ = await Self.consumeClaudeKeychainFingerprintChangeWithoutPrompt() } - await self.handleProviderFetchFailure(provider: provider, error: error) + await self.handleProviderFetchFailure( + provider: provider, + error: error, + generation: context.generation) } } @@ -293,9 +464,14 @@ extension UsageStore { self.lastTokenFetchAt.removeValue(forKey: .claude) } - private func handleProviderFetchFailure(provider: UsageProvider, error: Error) async { + private func handleProviderFetchFailure( + provider: UsageProvider, + error: Error, + generation: UInt64) async + { let shouldNotifyPermissionPrompt = Self.isPermissionPromptWaiting(error) await MainActor.run { + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } let hadPriorData = self.snapshots[provider] != nil let preservesPriorData = Self.shouldPreservePriorSnapshot( after: error, @@ -336,6 +512,7 @@ extension UsageStore { self.postPermissionPromptNotificationIfNeeded(provider: provider, error: error) } } + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } if let runtime = self.providerRuntimes[provider] { let context = ProviderRuntimeContext( provider: provider, settings: self.settings, store: self) diff --git a/Sources/CodexBar/UsageStore+TokenAccounts.swift b/Sources/CodexBar/UsageStore+TokenAccounts.swift index 5f0476c7..aa7d4cad 100644 --- a/Sources/CodexBar/UsageStore+TokenAccounts.swift +++ b/Sources/CodexBar/UsageStore+TokenAccounts.swift @@ -75,7 +75,7 @@ extension UsageStore { projection.visibleAccounts.count > 1 } - func refreshCodexVisibleAccountsForMenu() async { + func refreshCodexVisibleAccountsForMenu(generation: UInt64? = nil) async { let projection = self.freshCodexVisibleAccountProjectionForAccountRefresh() let accounts = self.limitedCodexVisibleAccounts( projection.visibleAccounts, @@ -131,6 +131,7 @@ extension UsageStore { let currentProjection = self.freshCodexVisibleAccountProjectionForAccountRefresh( requireLiveManagedAuthFor: managedAccountIDsWithReadableAuthAtStart) + guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return } let currentSnapshots = snapshots.compactMap { snapshot -> CodexAccountUsageSnapshot? in guard let currentAccount = Self.currentCodexVisibleAccount( matching: snapshot.account, @@ -188,7 +189,8 @@ extension UsageStore { selectedOutcome, account: currentSelectedAccount, snapshot: currentSelectedSnapshot, - sourceLabel: selectedSourceLabel) + sourceLabel: selectedSourceLabel, + generation: generation) } } else { _ = self.prepareCodexAccountScopedRefreshIfNeeded() @@ -386,7 +388,11 @@ extension UsageStore { } } - func refreshTokenAccounts(provider: UsageProvider, accounts: [ProviderTokenAccount]) async { + func refreshTokenAccounts( + provider: UsageProvider, + accounts: [ProviderTokenAccount], + generation: UInt64? = nil) async + { let selectedAccount = self.settings.selectedTokenAccount(for: provider) let limitedAccounts = self.limitedTokenAccounts(accounts, selected: selectedAccount) let effectiveSelected = selectedAccount ?? limitedAccounts.first @@ -405,6 +411,7 @@ extension UsageStore { var sawAnyNonCancellationOutcome = false let results = await self.fetchTokenAccountOutcomes(provider: provider, accounts: limitedAccounts) + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } for result in results { let account = result.account let outcome = result.outcome @@ -445,9 +452,11 @@ extension UsageStore { selectedOutcome, provider: provider, account: effectiveSelected, - fallbackSnapshot: selectedSnapshot) + fallbackSnapshot: selectedSnapshot, + generation: generation) } + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } await self.recordFetchedTokenAccountPlanUtilizationHistory( provider: provider, samples: historySamples, @@ -632,6 +641,9 @@ extension UsageStore { codexActiveSourceOverride: codexActiveSourceOverride) let fetcher = ProviderRegistry.makeFetcher(base: self.codexFetcher, provider: provider, env: env) let verbose = self.settings.isVerboseLoggingEnabled + let contextProvider = provider + let originalAccountToken = account?.token + let originalManualToken = provider == .stepfun ? self.settings.stepfunToken : nil return ProviderFetchContext( runtime: .app, sourceMode: sourceMode, @@ -646,19 +658,26 @@ extension UsageStore { claudeFetcher: self.claudeFetcher, browserDetection: self.browserDetection, selectedTokenAccountID: account?.id, - tokenAccountTokenUpdater: { [weak settings = self.settings] provider, accountID, token in + tokenAccountTokenUpdater: { [weak self] provider, accountID, token in await MainActor.run { - settings?.updateTokenAccount( + guard let self, provider == contextProvider, + self.settings.tokenAccounts(for: provider) + .first(where: { $0.id == accountID })?.token == originalAccountToken + else { + return + } + self.settings.updateTokenAccount( provider: provider, accountID: accountID, token: token) } }, - providerManualTokenUpdater: { [weak settings = self.settings] provider, token in + providerManualTokenUpdater: { [weak self] provider, token in await MainActor.run { - if provider == .stepfun { - settings?.stepfunToken = token - } + guard let self, provider == .stepfun, + self.settings.stepfunToken == originalManualToken + else { return } + self.settings.stepfunToken = token } }, costUsageHistoryDays: self.settings.costUsageHistoryDays) @@ -1141,8 +1160,10 @@ extension UsageStore { _ outcome: ProviderFetchOutcome, account: CodexVisibleAccount, snapshot: UsageSnapshot?, - sourceLabel: String?) async + sourceLabel: String?, + generation: UInt64? = nil) async { + guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return } self.lastFetchAttempts[.codex] = outcome.attempts switch outcome.result { case .success: @@ -1159,6 +1180,7 @@ extension UsageStore { self.rememberLiveSystemCodexEmailIfNeeded(snapshot.accountEmail(for: .codex)) self.seedCodexAccountScopedRefreshGuard(accountEmail: account.email) await self.recordPlanUtilizationHistorySample(provider: .codex, snapshot: snapshot) + guard self.isCurrentProviderRefreshGeneration(.codex, generation: generation) else { return } self.recordCodexHistoricalSampleIfNeeded(snapshot: snapshot) case let .failure(error): guard let message = self.tokenAccountErrorMessage(error) else { @@ -1182,11 +1204,14 @@ extension UsageStore { _ outcome: ProviderFetchOutcome, provider: UsageProvider, account: ProviderTokenAccount?, - fallbackSnapshot: UsageSnapshot?) async + fallbackSnapshot: UsageSnapshot?, + generation: UInt64? = nil) async { await MainActor.run { + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } self.lastFetchAttempts[provider] = outcome.attempts } + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { return } switch outcome.result { case let .success(result): let scoped = result.usage.scoped(to: provider) @@ -1196,6 +1221,9 @@ extension UsageStore { scoped } let backfilled = await MainActor.run { + guard self.isCurrentProviderRefreshGeneration(provider, generation: generation) else { + return nil as UsageSnapshot? + } let backfilled = labeled.backfillingResetTimes(from: self.lastKnownResetSnapshots[provider]) self.handleQuotaWarningTransitions(provider: provider, snapshot: backfilled) self.handleSessionQuotaTransition(provider: provider, snapshot: backfilled) @@ -1206,6 +1234,7 @@ extension UsageStore { self.failureGates[provider]?.recordSuccess() return backfilled } + guard let backfilled else { return } await self.recordPlanUtilizationHistorySample( provider: provider, snapshot: backfilled, diff --git a/Sources/CodexBar/UsageStore.swift b/Sources/CodexBar/UsageStore.swift index bae9cef7..e3ea41a7 100644 --- a/Sources/CodexBar/UsageStore.swift +++ b/Sources/CodexBar/UsageStore.swift @@ -64,7 +64,7 @@ extension UsageStore { self.startTimer() self.updateProviderRuntimes() await self.refreshHistoricalDatasetIfNeeded() - await self.refresh() + await self.refreshForSettingsChange() } } } @@ -227,6 +227,11 @@ final class UsageStore { @ObservationIgnored var providerSpecs: [UsageProvider: ProviderSpec] = [:] @ObservationIgnored let providerMetadata: [UsageProvider: ProviderMetadata] @ObservationIgnored var providerRuntimes: [UsageProvider: any ProviderRuntime] = [:] + @ObservationIgnored var providerRefreshTasks: [UsageProvider: [ProviderRefreshTaskState]] = [:] + @ObservationIgnored var providerRefreshTaskGeneration: UInt64 = 0 + @ObservationIgnored var providerRefreshWaiterGeneration: UInt64 = 0 + @ObservationIgnored var latestProviderRefreshGenerations: [UsageProvider: UInt64] = [:] + @ObservationIgnored var providerRefreshCounts: [UsageProvider: Int] = [:] @ObservationIgnored private var providerAvailabilityCache: [UsageProvider: ProviderAvailabilityCacheEntry] = [:] @ObservationIgnored var accountInfoCache: [UsageProvider: AccountInfoCacheEntry] = [:] @ObservationIgnored private var timerTask: Task? @@ -549,8 +554,8 @@ final class UsageStore { func runRefresh( forceTokenUsage: Bool = false, - startupConnectivityRetryAttempt: Int?) - async + startupConnectivityRetryAttempt: Int?, + coalesceProviderRefreshesOverride: Bool? = nil) async { guard !self.isRefreshing else { return } self.prepareRefreshState() @@ -583,7 +588,12 @@ final class UsageStore { await withTaskGroup(of: Void.self) { group in for provider in refreshProviders { - group.addTask { await self.refreshProvider(provider) } + group.addTask { + await self.refreshProvider( + provider, + coalesceIfRefreshing: coalesceProviderRefreshesOverride ?? + (ProviderInteractionContext.current == .background)) + } if availableRefreshProviders.contains(provider) { group.addTask { await self.refreshStatus(provider) } } diff --git a/Sources/CodexBar/UsageStoreSupport.swift b/Sources/CodexBar/UsageStoreSupport.swift index 3ac92fc5..6f9aa532 100644 --- a/Sources/CodexBar/UsageStoreSupport.swift +++ b/Sources/CodexBar/UsageStoreSupport.swift @@ -1,6 +1,78 @@ import CodexBarCore import Foundation +final class ProviderRefreshTaskState: @unchecked Sendable { + let generation: UInt64 + + private let lock = NSLock() + private var task: Task? + private var waiterIDs: Set = [] + private var completed = false + private var retryRequired = false + + init(generation: UInt64) { + self.generation = generation + } + + func install(task: Task) { + self.lock.withLock { + self.task = task + } + } + + func addWaiter(_ waiterID: UInt64) -> Task? { + self.lock.withLock { + self.waiterIDs.insert(waiterID) + return self.task + } + } + + func cancelWaiter(_ waiterID: UInt64) { + let taskToCancel = self.lock.withLock { + guard self.waiterIDs.remove(waiterID) != nil else { return nil as Task? } + return self.waiterIDs.isEmpty && !self.completed ? self.task : nil + } + taskToCancel?.cancel() + } + + func finishWaiter(_ waiterID: UInt64) { + _ = self.lock.withLock { + self.waiterIDs.remove(waiterID) + } + } + + func markCompleted(retryRequired: Bool) { + self.lock.withLock { + self.completed = true + self.retryRequired = retryRequired + } + } + + func cancelTask() { + let task = self.lock.withLock { + self.completed ? nil : self.task + } + task?.cancel() + } + + func waitForTaskCompletion() async { + let task = self.lock.withLock { self.task } + await task?.value + } + + var isCompleted: Bool { + self.lock.withLock { self.completed } + } + + var shouldRetry: Bool { + self.lock.withLock { self.retryRequired } + } + + var canRemove: Bool { + self.lock.withLock { self.completed && self.waiterIDs.isEmpty } + } +} + enum ProviderStatusIndicator: String { case none case minor diff --git a/Tests/CodexBarTests/MenuCardSubtitleTests.swift b/Tests/CodexBarTests/MenuCardSubtitleTests.swift index 8407c1c1..6cda8e0d 100644 --- a/Tests/CodexBarTests/MenuCardSubtitleTests.swift +++ b/Tests/CodexBarTests/MenuCardSubtitleTests.swift @@ -46,4 +46,49 @@ struct MenuCardSubtitleTests { #expect(model.subtitleText == UsageFormatter.updatedString(from: updatedAt, now: now)) } + + @Test + func `subtitle shows refreshing while cached snapshot remains visible`() throws { + let updatedAt = Date(timeIntervalSinceReferenceDate: 0) + let now = updatedAt.addingTimeInterval(5 * 3600) + let snapshot = UsageSnapshot( + primary: RateWindow( + usedPercent: 22, + windowMinutes: 300, + resetsAt: now.addingTimeInterval(3000), + resetDescription: nil), + secondary: nil, + tertiary: nil, + updatedAt: updatedAt, + identity: ProviderIdentitySnapshot( + providerID: .codex, + accountEmail: "codex@example.com", + accountOrganization: nil, + loginMethod: "Plus Plan")) + let metadata = try #require(ProviderDefaults.metadata[.codex]) + + let model = UsageMenuCardView.Model.make(.init( + provider: .codex, + metadata: metadata, + snapshot: snapshot, + credits: nil, + creditsError: nil, + dashboard: nil, + dashboardError: nil, + tokenSnapshot: nil, + tokenError: nil, + account: AccountInfo(email: "codex@example.com", plan: "Plus Plan"), + isRefreshing: true, + lastError: nil, + usageBarsShowUsed: false, + resetTimeDisplayStyle: .countdown, + tokenCostUsageEnabled: false, + showOptionalCreditsAndExtraUsage: true, + hidePersonalInfo: false, + now: now)) + + #expect(model.subtitleText == "Refreshing…") + #expect(model.subtitleStyle == .loading) + #expect(!model.metrics.isEmpty) + } } diff --git a/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift b/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift index e2e1fbaf..92ebb005 100644 --- a/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift +++ b/Tests/CodexBarTests/StatusMenuClosedPreparationTests.swift @@ -32,6 +32,9 @@ extension StatusMenuTests { defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } controller.menuRefreshEnabledOverrideForTesting = true + for _ in 0..<20 { + await Task.yield() + } let menu = controller.makeMenu() // Simulate a closed menu that was attached by an icon update but has never been opened. controller.fallbackMenu = menu @@ -80,6 +83,9 @@ extension StatusMenuTests { defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } controller.menuRefreshEnabledOverrideForTesting = true + for _ in 0..<20 { + await Task.yield() + } let menu = controller.makeMenu() controller.fallbackMenu = menu controller.statusItem.menu = menu @@ -101,6 +107,8 @@ extension StatusMenuTests { #expect(controller.menuVersions[key] == openedVersion) store.isRefreshing = false + controller.fallbackMenu = menu + controller.statusItem.menu = menu controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) for _ in 0..<40 where controller.menuVersions[key] == openedVersion { await Task.yield() diff --git a/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift b/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift new file mode 100644 index 00000000..00dd8dbb --- /dev/null +++ b/Tests/CodexBarTests/StatusMenuInstantOpenTests.swift @@ -0,0 +1,1540 @@ +import AppKit +import CodexBarCore +import Foundation +import Testing +@testable import CodexBar + +extension StatusMenuTests { + @Test + func `opening fresh menu does not schedule deferred refresh`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + var providerRefreshCount = 0 + var refreshInteractions: [ProviderInteraction] = [] + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + refreshInteractions.append(ProviderInteractionContext.current) + providerRefreshCount += 1 + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + StatusItemController.setClosedMenuPreparationDelayForTesting(.zero) + defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } + + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) + defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + + for _ in 0..<20 { + await Task.yield() + } + #expect(providerRefreshCount == 0) + #expect(!controller.deferredMenuInteractionRefreshPending) + + controller.menuDidClose(menu) + for _ in 0..<40 { + await Task.yield() + } + + #expect(providerRefreshCount == 0) + #expect(refreshInteractions.isEmpty) + } + + @Test + func `menu open with missing data refreshes asynchronously while tracking`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + var providerRefreshCount = 0 + var refreshInteractions: [ProviderInteraction] = [] + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + refreshInteractions.append(ProviderInteractionContext.current) + providerRefreshCount += 1 + store._setSnapshotForTesting( + UsageSnapshot( + primary: RateWindow( + usedPercent: 25, + windowMinutes: 300, + resetsAt: Date().addingTimeInterval(3600), + resetDescription: nil), + secondary: nil, + updatedAt: Date()), + provider: .codex) + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + StatusItemController.setClosedMenuPreparationDelayForTesting(.zero) + defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } + + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) + defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + #expect(controller.deferredMenuInteractionRefreshPending) + + for _ in 0..<40 where providerRefreshCount == 0 { + await Task.yield() + } + + #expect(providerRefreshCount == 1) + #expect(refreshInteractions == [.background]) + for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending { + await Task.yield() + } + #expect(!controller.deferredMenuInteractionRefreshPending) + controller.menuDidClose(menu) + #expect(!controller.deferredMenuInteractionRefreshPending) + } + + @Test + func `menu open renders cached data immediately after data only invalidation`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + var providerRefreshCount = 0 + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + providerRefreshCount += 1 + } + defer { store._test_providerRefreshOverride = nil } + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + + controller.menuRefreshEnabledOverrideForTesting = true + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let key = ObjectIdentifier(menu) + let cachedItemCount = menu.items.count + let cachedVersion = controller.menuVersions[key] + controller.lastMenuAdjunctReadinessSignature = "stale-baseline" + + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + let dataOnlyVersion = controller.menuContentVersion + var asyncRebuilds = 0 + controller._test_openMenuRebuildObserver = { _ in + asyncRebuilds += 1 + } + defer { controller._test_openMenuRebuildObserver = nil } + + controller.menuWillOpen(menu) + + #expect(cachedVersion != dataOnlyVersion) + #expect(menu.items.count == cachedItemCount) + #expect(controller.menuVersions[key] == cachedVersion) + #expect(asyncRebuilds == 0) + #expect(!controller.deferredMenuInteractionRefreshPending) + + for _ in 0..<40 where asyncRebuilds == 0 { + await Task.yield() + } + + #expect(asyncRebuilds == 1) + #expect(controller.menuVersions[key] == controller.menuContentVersion) + #expect(!controller.didMenuAdjunctReadinessChange()) + controller.menuDidClose(menu) + for _ in 0..<40 { + await Task.yield() + } + #expect(providerRefreshCount == 0) + } + + @Test + func `closing before cached menu rebuild keeps next open stale`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let key = ObjectIdentifier(menu) + let cachedVersion = controller.menuVersions[key] + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + + var rebuildGateEntries = 0 + var rebuildGate: CheckedContinuation? + controller._test_openMenuRefreshYieldOverride = { + rebuildGateEntries += 1 + await withCheckedContinuation { continuation in + rebuildGate = continuation + } + } + defer { + rebuildGate?.resume() + controller._test_openMenuRefreshYieldOverride = nil + } + + controller.menuWillOpen(menu) + for _ in 0..<40 where rebuildGateEntries == 0 { + await Task.yield() + } + + #expect(rebuildGateEntries == 1) + #expect(controller.menuVersions[key] == cachedVersion) + controller.menuDidClose(menu) + #expect(controller.menuNeedsRefresh(menu)) + + rebuildGate?.resume() + rebuildGate = nil + controller._test_openMenuRefreshYieldOverride = nil + for _ in 0..<20 { + await Task.yield() + } + + controller.menuWillOpen(menu) + for _ in 0..<40 where controller.menuNeedsRefresh(menu) { + await Task.yield() + } + + #expect(!controller.menuNeedsRefresh(menu)) + controller.menuDidClose(menu) + } + + @Test + func `menu open rebuilds synchronously after provider identity changes`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "old@example.com"), + provider: .codex) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)] + + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "new@example.com"), + provider: .codex) + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion) + #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion) + } + + @Test + func `overview menu rebuilds synchronously after secondary provider identity changes`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.mergedMenuLastSelectedWasOverview = true + self.enableProvidersForInstantOpenTesting([.codex, .claude], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "codex@example.com"), + provider: .codex) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "old@example.com", provider: .claude), + provider: .claude) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + controller.selectedMenuProvider = .codex + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)] + + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "new@example.com", provider: .claude), + provider: .claude) + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion) + #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion) + } + + @Test + func `stacked Codex menu rebuilds synchronously after secondary account identity changes`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.multiAccountMenuLayout = .stacked + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "selected@example.com"), + provider: .codex) + let selectedAccount = CodexVisibleAccount( + id: "selected", + email: "selected@example.com", + workspaceLabel: nil, + workspaceAccountID: nil, + authFingerprint: nil, + storedAccountID: nil, + selectionSource: .liveSystem, + isActive: true, + isLive: true, + canReauthenticate: false, + canRemove: false) + let secondaryAccount = CodexVisibleAccount( + id: "secondary", + email: "secondary@example.com", + workspaceLabel: nil, + workspaceAccountID: nil, + authFingerprint: nil, + storedAccountID: nil, + selectionSource: .liveSystem, + isActive: false, + isLive: false, + canReauthenticate: false, + canRemove: false) + store.codexAccountSnapshots = [ + CodexAccountUsageSnapshot( + account: selectedAccount, + snapshot: self.instantOpenSnapshot(email: "selected@example.com"), + error: nil, + sourceLabel: "test"), + CodexAccountUsageSnapshot( + account: secondaryAccount, + snapshot: self.instantOpenSnapshot(email: "old@example.com"), + error: nil, + sourceLabel: "test"), + ] + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let cachedVersion = controller.menuVersions[ObjectIdentifier(menu)] + + store.codexAccountSnapshots[1] = CodexAccountUsageSnapshot( + account: secondaryAccount, + snapshot: self.instantOpenSnapshot(email: "new@example.com"), + error: nil, + sourceLabel: "test") + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.menuVersions[ObjectIdentifier(menu)] != cachedVersion) + #expect(controller.menuVersions[ObjectIdentifier(menu)] == controller.menuContentVersion) + } + + @Test + func `cache preserving structural invalidation rebuilds synchronously on open`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let key = ObjectIdentifier(menu) + let cachedVersion = controller.menuVersions[key] + + controller.preservingMergedSwitcherContentCachesDuringInvalidation { + controller.invalidateMenus() + } + #expect(controller.menuVersions[key] == cachedVersion) + #expect(controller.menuContentVersion != controller.latestDataOnlyMenuContentVersion) + + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.menuVersions[key] == controller.menuContentVersion) + #expect(controller.openMenuRebuildTasks[key] == nil) + } + + @Test + func `data invalidation after cache preserving structural invalidation still rebuilds synchronously`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + let key = ObjectIdentifier(menu) + let cachedVersion = controller.menuVersions[key] + + controller.preservingMergedSwitcherContentCachesDuringInvalidation { + controller.invalidateMenus() + } + let structuralVersion = controller.menuContentVersion + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + + #expect(controller.menuVersions[key] == cachedVersion) + #expect(controller.latestStructuralMenuContentVersion == structuralVersion) + #expect(controller.menuContentVersion == controller.latestDataOnlyMenuContentVersion) + + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.menuVersions[key] == controller.menuContentVersion) + #expect(controller.openMenuRebuildTasks[key] == nil) + } + + @Test + func `menu open does not overlap provider specific refresh`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + let refreshGate = BlockingInstantOpenProviderRefresh() + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + store._setSnapshotForTesting( + UsageSnapshot( + primary: RateWindow( + usedPercent: 25, + windowMinutes: 300, + resetsAt: Date().addingTimeInterval(3600), + resetDescription: nil), + secondary: nil, + updatedAt: Date()), + provider: .codex) + } + defer { store._test_providerRefreshOverride = nil } + let existingRefreshTask = Task { + await store.refreshProvider(.codex) + } + await refreshGate.waitUntilStarted(count: 1) + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + for _ in 0..<40 { + await Task.yield() + } + + #expect(await refreshGate.startCount == 1) + #expect(store.refreshingProviders.contains(.codex)) + await refreshGate.releaseFirst() + await existingRefreshTask.value + for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending { + await Task.yield() + } + #expect(!store.isRefreshing) + #expect(!controller.deferredMenuInteractionRefreshPending) + } + + @Test + func `cached menu rebuilds after active provider refresh completes`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + let refreshGate = BlockingInstantOpenProviderRefresh() + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + + let existingRefreshTask = Task { + await store.refreshProvider(.codex) + } + await refreshGate.waitUntilStarted(count: 1) + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + #expect(controller.menuNeedsRefresh(menu)) + + await refreshGate.releaseFirst() + await existingRefreshTask.value + for _ in 0..<80 where controller.menuNeedsRefresh(menu) { + await Task.yield() + } + + #expect(await refreshGate.startCount == 1) + #expect(!controller.menuNeedsRefresh(menu)) + } + + @Test + func `menu rebuilds after displayed provider completes while another provider refreshes`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "old@example.com"), + provider: .codex) + store.refreshingProviders = [.claude] + defer { store.refreshingProviders = [] } + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu(for: .codex) + controller.populateMenu(menu, provider: .codex) + controller.markMenuFresh(menu) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "new@example.com"), + provider: .codex) + controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) + + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + for _ in 0..<80 where controller.menuNeedsRefresh(menu) { + await Task.yield() + } + + #expect(!controller.menuNeedsRefresh(menu)) + } + + @Test + func `user refresh supersedes background provider refresh`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshGate = BlockingInstantOpenProviderRefresh() + var refreshInteractions: [ProviderInteraction] = [] + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + refreshInteractions.append(ProviderInteractionContext.current) + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + + let backgroundRefreshTask = Task { + await ProviderInteractionContext.$current.withValue(.background) { + await store.refreshProvider(.codex, coalesceIfRefreshing: true) + } + } + await refreshGate.waitUntilStarted(count: 1) + + let userRefreshTask = Task { + await ProviderInteractionContext.$current.withValue(.userInitiated) { + await store.refresh() + } + } + for _ in 0..<40 { + await Task.yield() + } + #expect(await refreshGate.startCount == 1) + + await refreshGate.releaseFirst() + await refreshGate.waitUntilStarted(count: 2) + await userRefreshTask.value + await backgroundRefreshTask.value + #expect(await refreshGate.startCount == 2) + #expect(refreshInteractions == [.background, .userInitiated]) + } + + @Test + func `settings refresh supersedes background provider refresh without becoming user initiated`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshGate = BlockingInstantOpenProviderRefresh() + var refreshInteractions: [ProviderInteraction] = [] + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + refreshInteractions.append(ProviderInteractionContext.current) + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + + let backgroundRefreshTask = Task { + await store.refreshProvider(.codex, coalesceIfRefreshing: true) + } + await refreshGate.waitUntilStarted(count: 1) + + let settingsRefreshTask = Task { + await store.refreshForSettingsChange() + } + for _ in 0..<40 { + await Task.yield() + } + #expect(await refreshGate.startCount == 1) + + await refreshGate.releaseFirst() + await refreshGate.waitUntilStarted(count: 2) + await settingsRefreshTask.value + await backgroundRefreshTask.value + #expect(await refreshGate.startCount == 2) + #expect(refreshInteractions == [.background, .background]) + } + + @Test + func `superseded provider refresh drains before newer result`() async throws { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableProvidersForInstantOpenTesting([.claude], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshes = OrderedInstantOpenProviderRefresh() + let baseSpec = try #require(store.providerSpecs[.claude]) + let baseDescriptor = baseSpec.descriptor + let strategy = InstantOpenProviderFetchStrategy { + await refreshes.awaitSnapshot() + } + store.providerSpecs[.claude] = ProviderSpec( + style: baseSpec.style, + isEnabled: baseSpec.isEnabled, + descriptor: ProviderDescriptor( + id: .claude, + metadata: baseDescriptor.metadata, + branding: baseDescriptor.branding, + tokenCost: baseDescriptor.tokenCost, + fetchPlan: ProviderFetchPlan( + sourceModes: [.auto, .cli, .oauth], + pipeline: ProviderFetchPipeline { _ in [strategy] }), + cli: baseDescriptor.cli), + makeFetchContext: baseSpec.makeFetchContext) + + let olderTask = Task { + await store.refreshProvider(.claude) + } + await refreshes.waitUntilStarted(count: 1) + let newerTask = Task { + await store.refreshProvider(.claude) + } + for _ in 0..<40 { + await Task.yield() + } + #expect(await refreshes.startCount == 1) + + await refreshes.resume( + call: 1, + snapshot: self.instantOpenSnapshot( + email: "old@example.com", + provider: .claude, + percent: 10)) + await refreshes.waitUntilStarted(count: 2) + await refreshes.resume( + call: 2, + snapshot: self.instantOpenSnapshot( + email: "new@example.com", + provider: .claude, + percent: 80)) + await newerTask.value + await olderTask.value + + #expect(store.snapshot(for: .claude)?.primary?.usedPercent == 80) + #expect(store.snapshot(for: .claude)?.accountEmail(for: .claude) == "new@example.com") + } + + @Test + func `superseded provider refresh cannot overwrite manually changed token`() async throws { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableProvidersForInstantOpenTesting([.stepfun], settings: settings) + settings.stepfunToken = "initial-token" + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshes = OrderedInstantOpenProviderMutation() + let baseSpec = try #require(store.providerSpecs[.stepfun]) + let baseDescriptor = baseSpec.descriptor + let strategy = InstantOpenProviderMutationFetchStrategy(mutations: refreshes) + store.providerSpecs[.stepfun] = ProviderSpec( + style: baseSpec.style, + isEnabled: baseSpec.isEnabled, + descriptor: ProviderDescriptor( + id: .stepfun, + metadata: baseDescriptor.metadata, + branding: baseDescriptor.branding, + tokenCost: baseDescriptor.tokenCost, + fetchPlan: ProviderFetchPlan( + sourceModes: [.auto, .web], + pipeline: ProviderFetchPipeline { _ in [strategy] }), + cli: baseDescriptor.cli), + makeFetchContext: baseSpec.makeFetchContext) + + let olderTask = Task { + await store.refreshProvider(.stepfun) + } + await refreshes.waitUntilStarted(count: 1) + let newerTask = Task { + await store.refreshProvider(.stepfun) + } + for _ in 0..<40 { + await Task.yield() + } + #expect(await refreshes.startCount == 1) + + settings.stepfunToken = "user-token" + await refreshes.resume(call: 1, token: "old-token") + await refreshes.waitUntilStarted(count: 2) + #expect(settings.stepfunToken == "user-token") + await refreshes.resume(call: 2, token: "new-token") + await newerTask.value + await olderTask.value + + #expect(settings.stepfunToken == "new-token") + } + + @Test + func `superseded provider refresh preserves rotated token when credential is unchanged`() async throws { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableProvidersForInstantOpenTesting([.stepfun], settings: settings) + settings.stepfunToken = "initial-token" + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshes = OrderedInstantOpenProviderMutation() + let baseSpec = try #require(store.providerSpecs[.stepfun]) + let baseDescriptor = baseSpec.descriptor + let strategy = InstantOpenProviderMutationFetchStrategy(mutations: refreshes) + store.providerSpecs[.stepfun] = ProviderSpec( + style: baseSpec.style, + isEnabled: baseSpec.isEnabled, + descriptor: ProviderDescriptor( + id: .stepfun, + metadata: baseDescriptor.metadata, + branding: baseDescriptor.branding, + tokenCost: baseDescriptor.tokenCost, + fetchPlan: ProviderFetchPlan( + sourceModes: [.auto, .web], + pipeline: ProviderFetchPipeline { _ in [strategy] }), + cli: baseDescriptor.cli), + makeFetchContext: baseSpec.makeFetchContext) + + let olderTask = Task { + await store.refreshProvider(.stepfun) + } + await refreshes.waitUntilStarted(count: 1) + let newerTask = Task { + await store.refreshProvider(.stepfun) + } + + await refreshes.resume(call: 1, token: "rotated-token") + await refreshes.waitUntilStarted(count: 2) + #expect(settings.stepfunToken == "rotated-token") + await refreshes.resume(call: 2, token: "newer-token") + await newerTask.value + await olderTask.value + + #expect(settings.stepfunToken == "newer-token") + } + + @Test + func `canceling provider refresh cancels its owned probe task`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshGate = BlockingInstantOpenProviderRefresh() + var refreshWasCancelled = false + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + refreshWasCancelled = Task.isCancelled + } + defer { store._test_providerRefreshOverride = nil } + + let refreshTask = Task { + await store.refreshProvider(.codex) + } + await refreshGate.waitUntilStarted(count: 1) + refreshTask.cancel() + await refreshGate.releaseFirst() + await refreshTask.value + + #expect(refreshWasCancelled) + } + + @Test + func `canceling refresh owner keeps shared provider probe alive`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + let refreshGate = BlockingInstantOpenProviderRefresh() + var refreshWasCancelled = false + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + refreshWasCancelled = Task.isCancelled + } + defer { store._test_providerRefreshOverride = nil } + + let ownerTask = Task { + await store.refreshProvider(.codex) + } + await refreshGate.waitUntilStarted(count: 1) + let sharedWaiterTask = Task { + await store.refreshProvider(.codex, coalesceIfRefreshing: true) + } + for _ in 0..<40 { + await Task.yield() + } + + ownerTask.cancel() + await refreshGate.releaseFirst() + await ownerTask.value + await sharedWaiterTask.value + + #expect(!refreshWasCancelled) + #expect(await refreshGate.startCount == 1) + } + + @Test + func `background refresh retries canceled provider probe with cached data`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "cached@example.com"), + provider: .codex) + let refreshGate = BlockingInstantOpenProviderRefresh() + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + + let ownerTask = Task { + await store.refreshProvider(.codex) + } + await refreshGate.waitUntilStarted(count: 1) + ownerTask.cancel() + let backgroundTask = Task { + await store.refreshProvider(.codex, coalesceIfRefreshing: true) + } + for _ in 0..<40 { + await Task.yield() + } + await refreshGate.releaseFirst() + await ownerTask.value + await backgroundTask.value + + #expect(await refreshGate.startCount == 2) + } + + @Test + func `menu open refresh only retries the displayed provider`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + store.refreshingProviders.insert(.claude) + defer { store.refreshingProviders.remove(.claude) } + var refreshedProviders: [UsageProvider] = [] + store._test_providerRefreshOverride = { provider in + refreshedProviders.append(provider) + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuProviders[ObjectIdentifier(menu)] = .codex + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + for _ in 0..<40 where refreshedProviders.isEmpty { + await Task.yield() + } + + #expect(refreshedProviders == [.codex]) + } + + @Test + func `opening fresh split menu preserves another provider deferred retry`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "claude@example.com", provider: .claude), + provider: .claude) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.seconds(60)) + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.seconds(60)) + defer { + StatusItemController.resetMenuOpenRefreshDelayForTesting() + StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() + } + + let codexMenu = controller.makeMenu(for: .codex) + controller.menuWillOpen(codexMenu) + controller.menuDidClose(codexMenu) + #expect(controller.deferredMenuInteractionRefreshProviders == [.codex]) + + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + let claudeMenu = controller.makeMenu(for: .claude) + controller.menuWillOpen(claudeMenu) + defer { controller.menuDidClose(claudeMenu) } + for _ in 0..<40 { + await Task.yield() + } + + #expect(controller.deferredMenuInteractionRefreshProviders == [.codex]) + #expect(controller.deferredMenuInteractionRefreshPending) + } + + @Test + func `overview defers only providers that need retry`() { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.mergedMenuLastSelectedWasOverview = true + self.enableProvidersForInstantOpenTesting([.claude, .codex], settings: settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + store._setSnapshotForTesting( + self.instantOpenSnapshot(email: "claude@example.com", provider: .claude), + provider: .claude) + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.seconds(60)) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + + #expect(controller.deferredMenuInteractionRefreshProviders == [.codex]) + } + + @Test + func `closing overview menu stops before refreshing another provider`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.mergedMenuLastSelectedWasOverview = true + self.enableProvidersForInstantOpenTesting([.codex, .openai], settings: settings) + settings.updateProviderConfig(provider: .openai) { config in + config.apiKey = "test-openai-key" + } + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + store._setSnapshotForTesting(nil, provider: .openai) + let refreshGate = BlockingInstantOpenProviderRefresh() + store._test_providerRefreshOverride = { _ in + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.seconds(60)) + defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + await refreshGate.waitUntilStarted(count: 1) + controller.menuDidClose(menu) + await refreshGate.releaseFirst() + for _ in 0..<80 { + await Task.yield() + } + + #expect(await refreshGate.startCount == 1) + #expect(controller.deferredMenuInteractionRefreshPending) + } + + @Test + func `closing menu during missing data refresh preserves deferred retry`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + let refreshGate = BlockingInstantOpenProviderRefresh() + var refreshInteractions: [ProviderInteraction] = [] + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + refreshInteractions.append(ProviderInteractionContext.current) + await refreshGate.run() + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) + defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + await refreshGate.waitUntilStarted(count: 1) + #expect(controller.deferredMenuInteractionRefreshPending) + #expect(store.refreshingProviders.contains(.codex)) + + let periodicRefreshTask = Task { + await store.refresh() + } + for _ in 0..<40 { + await Task.yield() + } + #expect(await refreshGate.startCount == 1) + + controller.menuDidClose(menu) + #expect(controller.deferredMenuInteractionRefreshPending) + await refreshGate.releaseFirst() + await periodicRefreshTask.value + for _ in 0..<40 where store.isRefreshing { + await Task.yield() + } + for _ in 0..<40 { + await Task.yield() + } + #expect(controller.deferredMenuInteractionRefreshPending) + + controller.scheduleDeferredMenuInteractionRefreshIfNeeded(delay: .zero) + await refreshGate.waitUntilStarted(count: 2) + for _ in 0..<40 where controller.deferredMenuInteractionRefreshPending { + await Task.yield() + } + + #expect(await refreshGate.startCount == 2) + #expect(refreshInteractions == [.background, .background]) + #expect(!controller.deferredMenuInteractionRefreshPending) + } + + @Test + func `closing menu during successful missing data refresh clears deferred retry`() async { + self.disableMenuCardsForTesting() + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodexForInstantOpenTesting(settings) + + let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) + store._setSnapshotForTesting(nil, provider: .codex) + let refreshGate = BlockingInstantOpenProviderRefresh() + store._test_providerRefreshOverride = { provider in + guard provider == .codex else { return } + await refreshGate.run() + store._setSnapshotForTesting( + UsageSnapshot( + primary: RateWindow( + usedPercent: 25, + windowMinutes: 300, + resetsAt: Date().addingTimeInterval(3600), + resetDescription: nil), + secondary: nil, + updatedAt: Date()), + provider: .codex) + } + defer { store._test_providerRefreshOverride = nil } + + let controller = StatusItemController( + store: store, + settings: settings, + account: UsageFetcher().loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) + defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } + StatusItemController.setMenuOpenRefreshDelayForTesting(.zero) + defer { StatusItemController.resetMenuOpenRefreshDelayForTesting() } + + let menu = controller.makeMenu() + controller.menuWillOpen(menu) + await refreshGate.waitUntilStarted(count: 1) + controller.menuDidClose(menu) + await refreshGate.releaseFirst() + + for _ in 0..<80 where controller.deferredMenuInteractionRefreshPending { + await Task.yield() + } + for _ in 0..<40 { + await Task.yield() + } + + #expect(await refreshGate.startCount == 1) + #expect(!controller.deferredMenuInteractionRefreshPending) + } + + private func enableOnlyCodexForInstantOpenTesting(_ settings: SettingsStore) { + self.enableProvidersForInstantOpenTesting([.codex], settings: settings) + } + + private func instantOpenSnapshot( + email: String, + provider: UsageProvider = .codex, + percent: Double = 25) -> UsageSnapshot + { + UsageSnapshot( + primary: RateWindow( + usedPercent: percent, + windowMinutes: 300, + resetsAt: Date().addingTimeInterval(3600), + resetDescription: nil), + secondary: nil, + updatedAt: Date(), + identity: ProviderIdentitySnapshot( + providerID: provider, + accountEmail: email, + accountOrganization: nil, + loginMethod: "ChatGPT")) + } + + private func enableProvidersForInstantOpenTesting( + _ enabledProviders: Set, + settings: SettingsStore) + { + let registry = ProviderRegistry.shared + for provider in UsageProvider.allCases { + guard let metadata = registry.metadata[provider] else { continue } + settings.setProviderEnabled( + provider: provider, + metadata: metadata, + enabled: enabledProviders.contains(provider)) + } + } +} + +private struct InstantOpenProviderFetchStrategy: ProviderFetchStrategy { + let loader: @Sendable () async -> UsageSnapshot + + var id: String { + "instant-open-provider-refresh-test" + } + + var kind: ProviderFetchKind { + .cli + } + + func isAvailable(_: ProviderFetchContext) async -> Bool { + true + } + + func fetch(_: ProviderFetchContext) async throws -> ProviderFetchResult { + let usage = await self.loader() + return self.makeResult(usage: usage, sourceLabel: self.id) + } + + func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool { + false + } +} + +private struct InstantOpenProviderMutationFetchStrategy: ProviderFetchStrategy { + let mutations: OrderedInstantOpenProviderMutation + + let id = "instant-open-provider-mutation-test" + let kind: ProviderFetchKind = .web + + func isAvailable(_: ProviderFetchContext) async -> Bool { + true + } + + func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult { + let token = await self.mutations.awaitToken() + await context.providerManualTokenUpdater?(.stepfun, token) + let usage = UsageSnapshot( + primary: RateWindow( + usedPercent: 25, + windowMinutes: 300, + resetsAt: Date().addingTimeInterval(3600), + resetDescription: nil), + secondary: nil, + updatedAt: Date()) + return self.makeResult(usage: usage, sourceLabel: self.id) + } + + func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool { + false + } +} + +private actor OrderedInstantOpenProviderRefresh { + private var started = 0 + private var startWaiters: [(count: Int, continuation: CheckedContinuation)] = [] + private var continuations: [Int: CheckedContinuation] = [:] + + var startCount: Int { + self.started + } + + func awaitSnapshot() async -> UsageSnapshot { + self.started += 1 + let call = self.started + self.resumeReadyStartWaiters() + return await withCheckedContinuation { continuation in + self.continuations[call] = continuation + } + } + + func waitUntilStarted(count: Int) async { + if self.started >= count { return } + await withCheckedContinuation { continuation in + self.startWaiters.append((count: count, continuation: continuation)) + } + } + + func resume(call: Int, snapshot: UsageSnapshot) { + self.continuations.removeValue(forKey: call)?.resume(returning: snapshot) + } + + private func resumeReadyStartWaiters() { + var remaining: [(count: Int, continuation: CheckedContinuation)] = [] + for waiter in self.startWaiters { + if self.started >= waiter.count { + waiter.continuation.resume() + } else { + remaining.append(waiter) + } + } + self.startWaiters = remaining + } +} + +private actor OrderedInstantOpenProviderMutation { + private var started = 0 + private var startWaiters: [(count: Int, continuation: CheckedContinuation)] = [] + private var continuations: [Int: CheckedContinuation] = [:] + + var startCount: Int { + self.started + } + + func awaitToken() async -> String { + self.started += 1 + let call = self.started + self.resumeReadyStartWaiters() + return await withCheckedContinuation { continuation in + self.continuations[call] = continuation + } + } + + func waitUntilStarted(count: Int) async { + if self.started >= count { return } + await withCheckedContinuation { continuation in + self.startWaiters.append((count: count, continuation: continuation)) + } + } + + func resume(call: Int, token: String) { + self.continuations.removeValue(forKey: call)?.resume(returning: token) + } + + private func resumeReadyStartWaiters() { + var remaining: [(count: Int, continuation: CheckedContinuation)] = [] + for waiter in self.startWaiters { + if self.started >= waiter.count { + waiter.continuation.resume() + } else { + remaining.append(waiter) + } + } + self.startWaiters = remaining + } +} + +private actor BlockingInstantOpenProviderRefresh { + private var started = 0 + private var startWaiters: [(count: Int, continuation: CheckedContinuation)] = [] + private var firstReleaseWaiters: [CheckedContinuation] = [] + private var firstReleased = false + + var startCount: Int { + self.started + } + + func run() async { + self.started += 1 + self.resumeReadyStartWaiters() + guard self.started == 1, !self.firstReleased else { return } + await withCheckedContinuation { continuation in + self.firstReleaseWaiters.append(continuation) + } + } + + func waitUntilStarted(count: Int) async { + if self.started >= count { return } + await withCheckedContinuation { continuation in + self.startWaiters.append((count: count, continuation: continuation)) + } + } + + func releaseFirst() { + self.firstReleased = true + let waiters = self.firstReleaseWaiters + self.firstReleaseWaiters.removeAll() + waiters.forEach { $0.resume() } + } + + private func resumeReadyStartWaiters() { + var remaining: [(count: Int, continuation: CheckedContinuation)] = [] + for waiter in self.startWaiters { + if self.started >= waiter.count { + waiter.continuation.resume() + } else { + remaining.append(waiter) + } + } + self.startWaiters = remaining + } +} diff --git a/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift b/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift index e25496bb..4a523d59 100644 --- a/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift +++ b/Tests/CodexBarTests/StatusMenuOpenRefreshTests.swift @@ -5,112 +5,6 @@ import Testing @testable import CodexBar extension StatusMenuTests { - @Test - func `opening fresh menu does not schedule deferred refresh`() async { - self.disableMenuCardsForTesting() - let settings = self.makeSettings() - settings.statusChecksEnabled = false - settings.refreshFrequency = .manual - settings.mergeIcons = false - self.enableOnlyCodex(settings) - - let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) - var providerRefreshCount = 0 - var refreshInteractions: [ProviderInteraction] = [] - store._test_providerRefreshOverride = { provider in - guard provider == .codex else { return } - refreshInteractions.append(ProviderInteractionContext.current) - providerRefreshCount += 1 - } - defer { store._test_providerRefreshOverride = nil } - - let controller = StatusItemController( - store: store, - settings: settings, - account: UsageFetcher().loadAccountInfo(), - updater: DisabledUpdaterController(), - preferencesSelection: PreferencesSelection(), - statusBar: self.makeStatusBarForTesting()) - defer { controller.releaseStatusItemsForTesting() } - StatusItemController.setClosedMenuPreparationDelayForTesting(.zero) - defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } - - controller.menuRefreshEnabledOverrideForTesting = true - StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) - defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } - - let menu = controller.makeMenu() - controller.menuWillOpen(menu) - - for _ in 0..<20 { - await Task.yield() - } - #expect(providerRefreshCount == 0) - #expect(!controller.deferredMenuInteractionRefreshPending) - - controller.menuDidClose(menu) - for _ in 0..<40 { - await Task.yield() - } - - #expect(providerRefreshCount == 0) - #expect(refreshInteractions.isEmpty) - } - - @Test - func `menu open with missing data defers automatic refresh until tracking ends`() async { - self.disableMenuCardsForTesting() - let settings = self.makeSettings() - settings.statusChecksEnabled = false - settings.refreshFrequency = .manual - settings.mergeIcons = false - self.enableOnlyCodex(settings) - - let store = self.makeCodexStore(settings: settings, dashboardAuthorized: false) - store._setSnapshotForTesting(nil, provider: .codex) - var providerRefreshCount = 0 - var refreshInteractions: [ProviderInteraction] = [] - store._test_providerRefreshOverride = { provider in - guard provider == .codex else { return } - refreshInteractions.append(ProviderInteractionContext.current) - providerRefreshCount += 1 - } - defer { store._test_providerRefreshOverride = nil } - - let controller = StatusItemController( - store: store, - settings: settings, - account: UsageFetcher().loadAccountInfo(), - updater: DisabledUpdaterController(), - preferencesSelection: PreferencesSelection(), - statusBar: self.makeStatusBarForTesting()) - defer { controller.releaseStatusItemsForTesting() } - StatusItemController.setClosedMenuPreparationDelayForTesting(.zero) - defer { StatusItemController.resetClosedMenuPreparationDelayForTesting() } - - controller.menuRefreshEnabledOverrideForTesting = true - StatusItemController.setDeferredMenuInteractionRefreshDelayForTesting(.zero) - defer { StatusItemController.resetDeferredMenuInteractionRefreshDelayForTesting() } - - let menu = controller.makeMenu() - controller.menuWillOpen(menu) - - for _ in 0..<20 { - await Task.yield() - } - #expect(providerRefreshCount == 0) - #expect(controller.deferredMenuInteractionRefreshPending) - - controller.menuDidClose(menu) - for _ in 0..<40 where providerRefreshCount == 0 { - await Task.yield() - } - - #expect(providerRefreshCount == 1) - #expect(refreshInteractions == [.background]) - #expect(!controller.deferredMenuInteractionRefreshPending) - } - @Test func `store observation marks open menu stale without rebuilding during tracking`() async { self.disableMenuCardsForTesting() @@ -193,10 +87,20 @@ extension StatusMenuTests { let menu = controller.makeMenu() controller.mergedMenu = menu controller.statusItem.menu = menu + for _ in 0..<20 { + await Task.yield() + } controller.populateMenu(menu, provider: nil) controller.markMenuFresh(menu) let key = ObjectIdentifier(menu) + for _ in 0..<40 { + await Task.yield() + } + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + controller.cancelAllClosedMenuRebuilds() + controller.closedMenusDeferredUntilNextOpen.removeAll(keepingCapacity: false) let openedVersion = controller.menuVersions[key] // Background data-refresh tick (stale allowed): closed prep is skipped entirely, so @@ -256,6 +160,12 @@ extension StatusMenuTests { controller.populateMenu(menu, provider: nil) controller.markMenuFresh(menu) let key = ObjectIdentifier(menu) + for _ in 0..<40 { + await Task.yield() + } + controller.populateMenu(menu, provider: nil) + controller.markMenuFresh(menu) + controller.cancelAllClosedMenuRebuilds() let openedVersion = controller.menuVersions[key] controller.invalidateMenus(allowStaleContentDuringDataRefresh: true) @@ -270,6 +180,9 @@ extension StatusMenuTests { controller.menuWillOpen(menu) defer { controller.menuDidClose(menu) } + for _ in 0..<40 where controller.menuVersions[key] != controller.menuContentVersion { + await Task.yield() + } #expect(controller.menuVersions[key] == controller.menuContentVersion) } diff --git a/Tests/CodexBarTests/StatusMenuTests.swift b/Tests/CodexBarTests/StatusMenuTests.swift index d59357da..73160c41 100644 --- a/Tests/CodexBarTests/StatusMenuTests.swift +++ b/Tests/CodexBarTests/StatusMenuTests.swift @@ -563,12 +563,19 @@ struct StatusMenuTests { settings.usageBarsShowUsed = true controller.handleProviderConfigChange(reason: "usageBarsShowUsed") - for _ in 0..<20 - where initialSwitcherID == (menu.items.first?.view as? ProviderSwitcherView).map(ObjectIdentifier.init) - { + for _ in 0..<20 { await Task.yield() } + #expect(controller.parentMenuRebuildsDeferredDuringTracking.contains(ObjectIdentifier(menu))) + if let initialSwitcherID, let currentSwitcher = menu.items.first?.view as? ProviderSwitcherView { + #expect(initialSwitcherID == ObjectIdentifier(currentSwitcher)) + } + + controller.menuDidClose(menu) + controller.menuWillOpen(menu) + defer { controller.menuDidClose(menu) } + let updatedSwitcher = menu.items.first?.view as? ProviderSwitcherView #expect(updatedSwitcher != nil) if let initialSwitcherID, let updatedSwitcher { diff --git a/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift b/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift index 49053cc9..1e505ce0 100644 --- a/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift +++ b/Tests/CodexBarTests/StatusMenuTokenAccountSwitcherTests.swift @@ -131,10 +131,15 @@ final class StatusMenuTokenAccountSwitcherTests: XCTestCase { let switcher = try XCTUnwrap(menu.items.compactMap { $0.view as? TokenAccountSwitcherView }.first) let selectionTask = try XCTUnwrap(switcher._test_select(index: 1)) - await blocker.waitUntilStarted(count: 2) XCTAssertEqual(settings.tokenAccountsData(for: .claude)?.clampedActiveIndex(), 1) + for _ in 0..<40 { + await Task.yield() + } + let startedBeforeDrain = await blocker.startedCallCount() + XCTAssertEqual(startedBeforeDrain, 1) await blocker.resumeAll(with: .success(self.snapshot(percent: 17))) + await blocker.waitUntilStarted(count: 2) await selectionTask.value await refreshTask.value let startedCallCount = await blocker.startedCallCount() From eda747ba6d4293a831398b8dadd2e2189793a7f6 Mon Sep 17 00:00:00 2001 From: bcssewl Date: Thu, 11 Jun 2026 01:33:58 +0200 Subject: [PATCH 27/51] Gate switcher shortcut event peek behind session HID counters (#1397) * perf: gate switcher event queue peeks Co-authored-by: bcssewl * docs: note switcher event gating --------- Co-authored-by: Peter Steinberger --- CHANGELOG.md | 1 + ...tatusItemController+ProviderSwitcher.swift | 89 ++++++++++- .../ProviderSwitcherEventPeekGateTests.swift | 149 ++++++++++++++++++ 3 files changed, 235 insertions(+), 4 deletions(-) create mode 100644 Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index c7636ecd..7ec2c03e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). - Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! - Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl! +- Menu bar: gate the provider-switcher shortcut monitor's event-queue peek behind session event counters so hover-driven menu tracking no longer calls `NSApp.nextEvent` on every run-loop pass (#1397). Thanks @bcssewl! - Development: disable Keychain access for unbundled executables to avoid repeated password prompts while preserving packaged app behavior (#1271). Thanks @Yuxin-Qiao! - Antigravity: exclude model quotas without a remaining fraction from family summaries so they no longer mask tracked usage in the automatic menu-bar metric (#1369). Thanks @Martin-Hausleitner! - Claude: add bundled Fable 5 pricing, account for native 1-hour cache-write usage, and refresh Sonnet 4.6 full-context rates (#1368). Thanks @MoollaMore! diff --git a/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift b/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift index b8eb310c..b9c6df97 100644 --- a/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift +++ b/Sources/CodexBar/StatusItemController+ProviderSwitcher.swift @@ -6,13 +6,83 @@ struct PendingProviderSwitcherRebuild { let provider: UsageProvider? } +/// Skips the event-queue peek on run-loop passes where no event of the monitored kinds +/// can possibly be pending. The menu-tracking run loop spins on every mouse move, and the +/// session-wide event counters for keys and clicks are far cheaper to read than +/// `NSApp.nextEvent` is to call, so gating on them removes the per-pass peek cost from +/// hover-heavy menu interaction (mouse moves never advance these counters). +@MainActor +final class ProviderSwitcherEventPeekGate { + private let eventTypes: [CGEventType] + private let counterProvider: (CGEventType) -> UInt32 + private var lastCounters: [UInt32]? + private var heldKeyCodes: Set = [] + private var emptyPeekBudget = 0 + + init( + eventTypes: [CGEventType], + counterProvider: @escaping (CGEventType) -> UInt32 = { type in + CGEventSource.counterForEventType(.combinedSessionState, eventType: type) + }) + { + self.eventTypes = eventTypes + self.counterProvider = counterProvider + } + + /// True when an event of a monitored kind may have been posted since the last check. + func shouldPeek() -> Bool { + let counters = self.eventTypes.map(self.counterProvider) + let countersChanged = self.lastCounters.map { counters != $0 } ?? true + self.lastCounters = counters + if countersChanged { + // The observer runs before run-loop sources. WindowServer can advance a counter + // one pass before AppKit queues the NSEvent, so require two empty peeks before + // considering the queue caught up. + self.emptyPeekBudget = max(self.emptyPeekBudget, 2) + } + // CoreGraphics does not count key autorepeat events. Keep peeking while a key is + // held so repeated provider-navigation events are still handled. + if !self.heldKeyCodes.isEmpty { return true } + return self.emptyPeekBudget > 0 + } + + func observe(_ event: NSEvent) { + // An unhandled event stays queued until AppKit processes it after this observer. + // Keep peeking until a later pass proves the matching queue is empty. + self.emptyPeekBudget = max(self.emptyPeekBudget, 1) + switch event.type { + case .keyDown: + self.heldKeyCodes.insert(event.keyCode) + case .keyUp: + self.heldKeyCodes.remove(event.keyCode) + default: + break + } + } + + func observeQueueEmpty(afterFindingEvent: Bool) { + if afterFindingEvent { + // A counter snapshot can represent multiple events that AppKit delivers across + // run-loop passes. Keep one empty proof pending after draining available events. + self.emptyPeekBudget = max(self.emptyPeekBudget - 1, 1) + } else if self.emptyPeekBudget > 0 { + self.emptyPeekBudget -= 1 + } + } +} + @MainActor final class ProviderSwitcherShortcutEventMonitor { private let callback: @MainActor (NSEvent) -> Bool private let observer: CFRunLoopObserver private var isActive = false - init(events: NSEvent.EventTypeMask, callback: @escaping @MainActor (NSEvent) -> Bool) { + init( + events: NSEvent.EventTypeMask, + peekGate: ProviderSwitcherEventPeekGate = ProviderSwitcherEventPeekGate( + eventTypes: [.keyDown, .keyUp, .leftMouseDown, .leftMouseUp]), + callback: @escaping @MainActor (NSEvent) -> Bool) + { self.callback = callback self.observer = CFRunLoopObserverCreateWithHandler( @@ -20,21 +90,32 @@ final class ProviderSwitcherShortcutEventMonitor { CFRunLoopActivity.beforeSources.rawValue, true, 0) - { [events, callback] _, _ in + { [events, peekGate, callback] _, _ in MainActor.assumeIsolated { + guard peekGate.shouldPeek() else { return } + var foundEvent = false + var blockedByUnhandledEvent = false while let event = NSApp.nextEvent( matching: events, until: .distantPast, inMode: .eventTracking, dequeue: false) { - guard callback(event) else { break } + foundEvent = true + peekGate.observe(event) + guard callback(event) else { + blockedByUnhandledEvent = true + break + } _ = NSApp.nextEvent( matching: events, until: .distantPast, inMode: .eventTracking, dequeue: true) } + if !blockedByUnhandledEvent { + peekGate.observeQueueEmpty(afterFindingEvent: foundEvent) + } } } } @@ -75,7 +156,7 @@ extension StatusItemController { self.removeProviderSwitcherShortcutMonitor() let monitor = ProviderSwitcherShortcutEventMonitor( - events: [.keyDown, .leftMouseDown, .leftMouseUp]) + events: [.keyDown, .keyUp, .leftMouseDown, .leftMouseUp]) { [weak self, weak menu] event in guard let self, let menu, diff --git a/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift b/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift new file mode 100644 index 00000000..27cc0111 --- /dev/null +++ b/Tests/CodexBarTests/ProviderSwitcherEventPeekGateTests.swift @@ -0,0 +1,149 @@ +import AppKit +import CoreGraphics +import Testing +@testable import CodexBar + +@MainActor +struct ProviderSwitcherEventPeekGateTests { + @Test + func `first check always peeks`() { + let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown], counterProvider: { _ in 7 }) + #expect(gate.shouldPeek()) + } + + @Test + func `unchanged counters skip the peek`() { + let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown, .leftMouseDown], counterProvider: { _ in 7 }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + #expect(!gate.shouldPeek()) + } + + @Test + func `any advanced counter re-enables the peek`() { + var keyDownCount: UInt32 = 1 + let gate = ProviderSwitcherEventPeekGate( + eventTypes: [.keyDown, .leftMouseDown], + counterProvider: { type in type == .keyDown ? keyDownCount : 3 }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + keyDownCount += 1 + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + } + + @Test + func `counter change keeps one follow up peek for AppKit queue delivery`() { + var keyDownCount: UInt32 = 1 + let gate = ProviderSwitcherEventPeekGate( + eventTypes: [.keyDown], + counterProvider: { _ in keyDownCount }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + + keyDownCount += 1 + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + } + + @Test + func `queued unhandled event burst keeps peeking until the queue is empty`() throws { + var eventCount: UInt32 = 1 + let gate = ProviderSwitcherEventPeekGate( + eventTypes: [.keyUp], + counterProvider: { _ in eventCount }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + + eventCount += 3 + #expect(gate.shouldPeek()) + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + #expect(gate.shouldPeek()) + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + #expect(gate.shouldPeek()) + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + #expect(gate.shouldPeek()) + + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + } + + @Test + func `handled event keeps peeking for delayed sibling from same counter snapshot`() throws { + var eventCount: UInt32 = 1 + let gate = ProviderSwitcherEventPeekGate( + eventTypes: [.keyUp], + counterProvider: { _ in eventCount }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + + eventCount += 2 + #expect(gate.shouldPeek()) + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + gate.observeQueueEmpty(afterFindingEvent: true) + + #expect(gate.shouldPeek()) + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + gate.observeQueueEmpty(afterFindingEvent: true) + + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + } + + @Test + func `held key keeps peeking for uncounted autorepeat events`() throws { + let gate = ProviderSwitcherEventPeekGate(eventTypes: [.keyDown, .keyUp], counterProvider: { _ in 7 }) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + + try gate.observe(Self.keyEvent(type: .keyDown, keyCode: 124)) + #expect(gate.shouldPeek()) + #expect(gate.shouldPeek()) + + try gate.observe(Self.keyEvent(type: .keyUp, keyCode: 124)) + #expect(gate.shouldPeek()) + gate.observeQueueEmpty(afterFindingEvent: false) + #expect(!gate.shouldPeek()) + } + + private static func keyEvent(type: NSEvent.EventType, keyCode: UInt16) throws -> NSEvent { + try #require(NSEvent.keyEvent( + with: type, + location: .zero, + modifierFlags: [], + timestamp: 0, + windowNumber: 0, + context: nil, + characters: "", + charactersIgnoringModifiers: "", + isARepeat: false, + keyCode: keyCode)) + } +} From b7772b240a4e5a4ceb53bf7a2d578753d6c22e68 Mon Sep 17 00:00:00 2001 From: kiranmagic7 Date: Thu, 11 Jun 2026 06:31:45 +0530 Subject: [PATCH 28/51] Defer merged icon redraws during menu tracking (#1409) * perf: defer merged icon redraws during menu tracking * docs: credit merged icon redraw fix --------- Co-authored-by: kiranmagic7 <209323973+kiranmagic7@users.noreply.github.com> Co-authored-by: Peter Steinberger --- CHANGELOG.md | 1 + .../StatusItemController+Animation.swift | 62 ++++++++- .../CodexBar/StatusItemController+Menu.swift | 4 + .../StatusItemController+Shutdown.swift | 1 + Sources/CodexBar/StatusItemController.swift | 24 +--- .../StatusItemAnimationSignatureTests.swift | 125 ++++++++++++++++++ 6 files changed, 195 insertions(+), 22 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7ec2c03e..342d7b82 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ - Codex: keep local token and cost history visible when remote quota data is unavailable (#1390). Thanks @vaibhavarora14! - Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra! - Menu bar: defer pasteboard writes and copy feedback outside the `NSMenu` tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405! +- Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7! - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). - Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! - Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl! diff --git a/Sources/CodexBar/StatusItemController+Animation.swift b/Sources/CodexBar/StatusItemController+Animation.swift index bbb42c44..3b545e6d 100644 --- a/Sources/CodexBar/StatusItemController+Animation.swift +++ b/Sources/CodexBar/StatusItemController+Animation.swift @@ -232,8 +232,13 @@ extension StatusItemController { } @discardableResult - func applyIcon(phase: Double?) -> Bool { + func applyIcon( + phase: Double?, + bypassMergedMenuTrackingDeferral: Bool = false) -> Bool + { guard let button = self.statusItem.button else { return false } + if !bypassMergedMenuTrackingDeferral, + self.deferMergedIconRenderDuringMenuTrackingIfNeeded() { return true } let style = self.store.iconStyle let showUsed = self.settings.usageBarsShowUsed @@ -395,6 +400,25 @@ extension StatusItemController { return false } + private func deferMergedIconRenderDuringMenuTrackingIfNeeded() -> Bool { + guard self.shouldMergeIcons, self.isMergedMenuOpen else { return false } + self.deferredMergedIconRenderAfterTracking = true + self.noteIconPerfRender(skipped: true) + return true + } + + func applyDeferredMergedIconRenderAfterTrackingIfNeeded() { + guard self.deferredMergedIconRenderAfterTracking else { return } + guard self.shouldMergeIcons else { + self.deferredMergedIconRenderAfterTracking = false + return + } + guard !self.isMergedMenuOpen else { return } + self.deferredMergedIconRenderAfterTracking = false + let phase: Double? = self.animationDriver == nil ? nil : self.animationPhase + self.applyIcon(phase: phase) + } + private func shouldSkipMergedIconRender(_ signature: String) -> Bool { guard self.shouldMergeIcons else { self.lastAppliedMergedIconRenderSignature = signature @@ -595,6 +619,42 @@ extension StatusItemController { return false } + func startQuotaWarningFlash(provider: UsageProvider, postedAt: Date = Date()) { + let until = postedAt.addingTimeInterval(Self.quotaWarningFlashDuration) + self.quotaWarningFlashUntil[provider] = until + self.quotaWarningFlashTasks[provider]?.cancel() + self.updateIcons() + self.applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded() + self.quotaWarningFlashTasks[provider] = Task { [weak self] in + try? await Task.sleep(for: .seconds(Self.quotaWarningFlashDuration)) + await MainActor.run { [weak self] in + self?.clearExpiredQuotaWarningFlash(provider: provider) + } + } + } + + func clearExpiredQuotaWarningFlash(provider: UsageProvider, now: Date = Date()) { + guard let currentUntil = self.quotaWarningFlashUntil[provider], + currentUntil <= now + else { + return + } + self.quotaWarningFlashUntil.removeValue(forKey: provider) + self.quotaWarningFlashTasks.removeValue(forKey: provider) + self.updateIcons() + self.applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded() + } + + private func applyQuotaWarningIconDuringMergedMenuTrackingIfNeeded() { + guard self.shouldMergeIcons, + self.isMergedMenuOpen + else { + return + } + let phase: Double? = self.animationDriver == nil ? nil : self.animationPhase + self.applyIcon(phase: phase, bypassMergedMenuTrackingDeferral: true) + } + static func quotaWarningFlashImage(base: NSImage) -> NSImage { let image = NSImage(size: base.size) image.lockFocus() diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift index 9dfebcf3..17fd31bf 100644 --- a/Sources/CodexBar/StatusItemController+Menu.swift +++ b/Sources/CodexBar/StatusItemController+Menu.swift @@ -159,6 +159,7 @@ extension StatusItemController { func forgetClosedMenu(_ menu: NSMenu) { let key = ObjectIdentifier(menu) + let wasMergedMenu = menu === self.mergedMenu if key == self.providerSwitcherShortcutMenuID { self.removeProviderSwitcherShortcutMonitor() @@ -185,6 +186,9 @@ extension StatusItemController { } self.parentMenuRebuildsDeferredDuringTracking.remove(key) self.scheduleDeferredMenuInteractionRefreshIfNeeded() + if wasMergedMenu { + self.applyDeferredMergedIconRenderAfterTrackingIfNeeded() + } } func menu(_ menu: NSMenu, willHighlight item: NSMenuItem?) { diff --git a/Sources/CodexBar/StatusItemController+Shutdown.swift b/Sources/CodexBar/StatusItemController+Shutdown.swift index 6e44db4e..5ca3f397 100644 --- a/Sources/CodexBar/StatusItemController+Shutdown.swift +++ b/Sources/CodexBar/StatusItemController+Shutdown.swift @@ -54,6 +54,7 @@ extension StatusItemController { self.openMenuInvalidationRetryTask = nil self.providerSelectionUIRefreshTask?.cancel() self.providerSelectionUIRefreshTask = nil + self.deferredMergedIconRenderAfterTracking = false self.providerSwitcherPointerInteractionMenuID = nil self.pendingProviderSwitcherPointerRebuild = nil } diff --git a/Sources/CodexBar/StatusItemController.swift b/Sources/CodexBar/StatusItemController.swift index b1e57e6e..ca719199 100644 --- a/Sources/CodexBar/StatusItemController.swift +++ b/Sources/CodexBar/StatusItemController.swift @@ -249,6 +249,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin /// Monotonic token used to ignore stale deferred provider-switcher menu rebuilds. var providerSwitcherUpdateToken = 0 var providerSelectionUIRefreshTask: Task? + var deferredMergedIconRenderAfterTracking = false var lastAppliedMergedIconRenderSignature: String? var lastAppliedProviderIconRenderSignatures: [UsageProvider: String] = [:] var lastObservedStoreIconWorkSignature: String? @@ -568,26 +569,6 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin self.startQuotaWarningFlash(provider: event.provider, postedAt: event.postedAt) } - func startQuotaWarningFlash(provider: UsageProvider, postedAt: Date = Date()) { - let until = postedAt.addingTimeInterval(Self.quotaWarningFlashDuration) - self.quotaWarningFlashUntil[provider] = until - self.quotaWarningFlashTasks[provider]?.cancel() - self.updateIcons() - self.quotaWarningFlashTasks[provider] = Task { [weak self] in - try? await Task.sleep(for: .seconds(Self.quotaWarningFlashDuration)) - await MainActor.run { [weak self] in - guard let self else { return } - if let currentUntil = self.quotaWarningFlashUntil[provider], - currentUntil <= Date() - { - self.quotaWarningFlashUntil.removeValue(forKey: provider) - self.quotaWarningFlashTasks.removeValue(forKey: provider) - self.updateIcons() - } - } - } - } - private func observeUpdaterChanges() { withObservationTracking { _ = self.updater.updateStatus.isUpdateReady @@ -670,7 +651,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin } } - private func updateIcons() { + func updateIcons() { #if DEBUG guard !self.isReleasedForTesting else { return } #endif @@ -683,6 +664,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin if self.shouldMergeIcons { let skippedMergedRender = self.applyIcon(phase: phase) if skippedMergedRender, + !self.deferredMergedIconRenderAfterTracking, let mergedMenu = self.mergedMenu, self.statusItem.menu === mergedMenu { diff --git a/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift b/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift index dfef3960..94e38001 100644 --- a/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift +++ b/Tests/CodexBarTests/StatusItemAnimationSignatureTests.swift @@ -138,6 +138,131 @@ struct StatusItemAnimationSignatureTests { #expect(button.imagePosition == .imageLeft) } + @Test + func `merged icon render defers while merged menu is tracking`() async throws { + let suite = "StatusItemAnimationSignatureTests-merged-icon-defers-during-tracking" + let defaults = try #require(UserDefaults(suiteName: suite)) + defaults.removePersistentDomain(forName: suite) + + let settings = SettingsStore( + userDefaults: defaults, + configStore: testConfigStore(suiteName: suite), + zaiTokenStore: NoopZaiTokenStore(), + syntheticTokenStore: NoopSyntheticTokenStore()) + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = true + settings.selectedMenuProvider = .codex + settings.menuBarShowsBrandIconWithPercent = false + settings.syntheticAPIToken = "synthetic-test-token" + + let registry = ProviderRegistry.shared + for provider in UsageProvider.allCases { + guard let metadata = registry.metadata[provider] else { continue } + settings.setProviderEnabled( + provider: provider, + metadata: metadata, + enabled: provider == .codex || provider == .synthetic) + } + + let fetcher = UsageFetcher() + let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings) + let controller = StatusItemController( + store: store, + settings: settings, + account: fetcher.loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: self.makeStatusBarForTesting()) + defer { controller.releaseStatusItemsForTesting() } + controller.menuRefreshEnabledOverrideForTesting = true + + func snapshot(usedPercent: Double) -> UsageSnapshot { + UsageSnapshot( + primary: RateWindow( + usedPercent: usedPercent, + windowMinutes: nil, + resetsAt: nil, + resetDescription: nil), + secondary: nil, + updatedAt: Date()) + } + + store._setSnapshotForTesting(snapshot(usedPercent: 20), provider: .codex) + for _ in 0..<10 where controller.animationDriver != nil { + await Task.yield() + } + #expect(controller.animationDriver == nil) + controller.applyIcon(phase: nil) + let initialSignature = try #require(controller.lastAppliedMergedIconRenderSignature) + + let menu = controller.makeMenu() + controller.mergedMenu = menu + controller.statusItem.menu = menu + controller.menuWillOpen(menu) + #expect(controller.isMergedMenuOpen) + + store._setSnapshotForTesting(nil, provider: .codex) + for _ in 0..<10 where controller.animationDriver == nil { + await Task.yield() + } + #expect(controller.animationDriver != nil) + #expect(controller.deferredMergedIconRenderAfterTracking) + + store._setSnapshotForTesting(snapshot(usedPercent: 80), provider: .codex) + for _ in 0..<10 where controller.animationDriver != nil { + await Task.yield() + } + #expect(controller.animationDriver == nil) + #expect(controller.deferredMergedIconRenderAfterTracking) + #expect(controller.lastAppliedMergedIconRenderSignature == initialSignature) + + controller.startQuotaWarningFlash(provider: .codex) + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=1") == true) + + let quotaWarningTask = controller.quotaWarningFlashTasks[.codex] + controller.clearExpiredQuotaWarningFlash(provider: .codex, now: .distantFuture) + quotaWarningTask?.cancel() + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=0") == true) + + controller.menuDidClose(menu) + + #expect(!controller.deferredMergedIconRenderAfterTracking) + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("warningFlash=0") == true) + + controller.menuWillOpen(menu) + settings.selectedMenuProvider = .synthetic + #expect(controller.primaryProviderForUnifiedIcon() == .synthetic) + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=codex") == true) + + controller.startQuotaWarningFlash(provider: .codex) + let switchedProviderWarningTask = controller.quotaWarningFlashTasks[.codex] + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("provider=synthetic") == true) + controller.clearExpiredQuotaWarningFlash(provider: .codex, now: .distantFuture) + switchedProviderWarningTask?.cancel() + controller.menuDidClose(menu) + + settings.selectedMenuProvider = .codex + for _ in 0..<10 where controller.primaryProviderForUnifiedIcon() != .codex { + await Task.yield() + } + + controller.menuWillOpen(menu) + store._setSnapshotForTesting(nil, provider: .codex) + controller.updateAnimationState() + controller.applyIcon(phase: controller.animationPhase) + #expect(controller.animationDriver != nil) + #expect(controller.deferredMergedIconRenderAfterTracking) + + controller.animationDriver?.stop() + controller.animationDriver = nil + controller.animationPhase = 0 + controller.menuDidClose(menu) + + #expect(controller.animationDriver == nil) + #expect(controller.lastAppliedMergedIconRenderSignature?.contains("primary=nil") == true) + } + @Test func `merged fallback provider follows enabled provider order`() throws { let suite = "StatusItemAnimationSignatureTests-merged-provider-order" From 0e0102c30fe6897948f9a940cdf9c918ddb7d21e Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Wed, 10 Jun 2026 19:03:22 -0700 Subject: [PATCH 29/51] Fix merged menu width after provider switches (#1411) Keep merged-provider tabs at one stable width, account for AppKit's retained tracked menu window width, and normalize every hosted card row including Subscription Utilization. Fixes #1410 --- CHANGELOG.md | 1 + .../CodexBar/StatusItemController+Menu.swift | 23 ++----- .../StatusItemController+MenuCardItems.swift | 10 ++- .../StatusItemController+MenuTracking.swift | 25 ++++++- .../StatusItemController+MenuWidthCache.swift | 43 ++++++++++++ .../MenuCardViewRecyclingTests.swift | 68 +++++++++++++++++++ 6 files changed, 145 insertions(+), 25 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 342d7b82..f62670b7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ - Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra! - Menu bar: defer pasteboard writes and copy feedback outside the `NSMenu` tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405! - Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7! +- Menu bar: keep one stable width across merged provider tabs and resize every hosted card row to AppKit's final menu width so provider switching no longer leaves a widened menu with inset submenu arrows (#1410). - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). - Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! - Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl! diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift index 17fd31bf..2e4f9c52 100644 --- a/Sources/CodexBar/StatusItemController+Menu.swift +++ b/Sources/CodexBar/StatusItemController+Menu.swift @@ -49,15 +49,6 @@ extension StatusItemController { } } - private func menuCardWidth( - for providers: [UsageProvider], - sections: [MenuDescriptor.Section]) -> CGFloat - { - _ = providers - let baselineWidth = Self.menuCardBaseWidth - return max(baselineWidth, self.measuredStandardMenuWidth(for: sections, baseWidth: baselineWidth)) - } - func makeMenu() -> NSMenu { guard self.shouldMergeIcons else { return self.makeMenu(for: nil) @@ -217,6 +208,7 @@ extension StatusItemController { menu: menu, provider: provider) } + defer { self.refreshMenuCardHeights(in: menu) } let enabledProviders = self.store.enabledProvidersForDisplay() let includesOverview = self.includesOverviewTab(enabledProviders: enabledProviders) @@ -244,16 +236,13 @@ extension StatusItemController { let openAIContext = self.openAIWebContext( currentProvider: currentProvider, showAllAccounts: showAllAccounts) - let descriptor = MenuDescriptor.build( + let descriptor = self.makeMenuDescriptor( provider: selectedProvider, - store: self.store, - settings: self.settings, - account: self.account, - managedCodexAccountCoordinator: self.managedCodexAccountCoordinator, - codexAccountPromotionCoordinator: self.codexAccountPromotionCoordinator, - updateReady: self.updater.updateStatus.isUpdateReady, includeContextualActions: !isOverviewSelected) - let menuWidth = self.menuCardWidth(for: enabledProviders, sections: descriptor.sections) + let menuWidth = self.menuCardWidth( + for: enabledProviders, + selectedProvider: selectedProvider, + descriptor: descriptor) let hasTokenSwitcher = menu.items.contains { $0.view is TokenAccountSwitcherView } let hasCodexSwitcher = menu.items.contains { $0.view is CodexAccountSwitcherView } diff --git a/Sources/CodexBar/StatusItemController+MenuCardItems.swift b/Sources/CodexBar/StatusItemController+MenuCardItems.swift index ebb86759..0f7a0750 100644 --- a/Sources/CodexBar/StatusItemController+MenuCardItems.swift +++ b/Sources/CodexBar/StatusItemController+MenuCardItems.swift @@ -3,12 +3,10 @@ import SwiftUI extension StatusItemController { func refreshMenuCardHeights(in menu: NSMenu) { - let cardItems = menu.items.filter { item in - (item.representedObject as? String)?.hasPrefix("menuCard") == true - } - for item in cardItems { - guard let view = item.view else { continue } - let width = self.renderedMenuWidth(for: menu) + let width = self.renderedMenuWidth(for: menu) + for item in menu.items { + guard let view = item.view, view is any MenuCardMeasuring else { continue } + guard abs(view.frame.width - width) > 0.5 else { continue } let id = item.representedObject as? String ?? "menuCard" let scope = self.menuProvider(for: menu)?.rawValue ?? id let height = self.cachedMenuCardHeight(for: id, scope: scope, width: width) { diff --git a/Sources/CodexBar/StatusItemController+MenuTracking.swift b/Sources/CodexBar/StatusItemController+MenuTracking.swift index 037edcdd..f7acd4a4 100644 --- a/Sources/CodexBar/StatusItemController+MenuTracking.swift +++ b/Sources/CodexBar/StatusItemController+MenuTracking.swift @@ -199,8 +199,29 @@ extension StatusItemController { } func renderedMenuWidth(for menu: NSMenu) -> CGFloat { - let measuredWidth = ceil(menu.size.width) - return max(measuredWidth, Self.menuCardBaseWidth) + let menuKey = ObjectIdentifier(menu) + let trackedWindowWidth: CGFloat? = if self.openMenus[menuKey] != nil { + menu.items.lazy.compactMap { item -> CGFloat? in + guard let window = item.view?.window else { return nil } + let contentWidth = window.contentLayoutRect.width + return contentWidth > 0 ? contentWidth : window.frame.width + }.first + } else { + nil + } + return Self.resolvedRenderedMenuWidth( + menuWidth: menu.size.width, + trackedWindowWidth: trackedWindowWidth) + } + + static func resolvedRenderedMenuWidth( + menuWidth: CGFloat, + trackedWindowWidth: CGFloat?) -> CGFloat + { + max( + ceil(menuWidth), + ceil(trackedWindowWidth ?? 0), + menuCardBaseWidth) } func rebuildClosedMenuIfNeeded(_ menu: NSMenu) { diff --git a/Sources/CodexBar/StatusItemController+MenuWidthCache.swift b/Sources/CodexBar/StatusItemController+MenuWidthCache.swift index a376958e..8f18e526 100644 --- a/Sources/CodexBar/StatusItemController+MenuWidthCache.swift +++ b/Sources/CodexBar/StatusItemController+MenuWidthCache.swift @@ -1,8 +1,51 @@ import AppKit +import CodexBarCore extension StatusItemController { private static let measuredStandardMenuWidthCacheLimit = 96 + func menuCardWidth( + for providers: [UsageProvider], + selectedProvider: UsageProvider?, + descriptor: MenuDescriptor) -> CGFloat + { + let sectionSets: [[MenuDescriptor.Section]] = if self.shouldMergeIcons, providers.count > 1 { + providers.map { provider in + if provider == selectedProvider { + return descriptor.sections + } + return self.makeMenuDescriptor( + provider: provider, + includeContextualActions: true).sections + } + } else { + [descriptor.sections] + } + return self.measuredMenuCardWidth(for: sectionSets) + } + + func measuredMenuCardWidth(for sectionSets: [[MenuDescriptor.Section]]) -> CGFloat { + let baselineWidth = Self.menuCardBaseWidth + return sectionSets.reduce(baselineWidth) { width, sections in + max(width, self.measuredStandardMenuWidth(for: sections, baseWidth: baselineWidth)) + } + } + + func makeMenuDescriptor( + provider: UsageProvider?, + includeContextualActions: Bool) -> MenuDescriptor + { + MenuDescriptor.build( + provider: provider, + store: self.store, + settings: self.settings, + account: self.account, + managedCodexAccountCoordinator: self.managedCodexAccountCoordinator, + codexAccountPromotionCoordinator: self.codexAccountPromotionCoordinator, + updateReady: self.updater.updateStatus.isUpdateReady, + includeContextualActions: includeContextualActions) + } + func measuredStandardMenuWidth(for sections: [MenuDescriptor.Section], baseWidth: CGFloat) -> CGFloat { let cacheKey = self.measuredStandardMenuWidthCacheKey(for: sections, baseWidth: baseWidth) if let cached = self.measuredStandardMenuWidthCache[cacheKey] { diff --git a/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift index 7c623bb6..5d48efd3 100644 --- a/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift +++ b/Tests/CodexBarTests/MenuCardViewRecyclingTests.swift @@ -35,6 +35,74 @@ extension StatusMenuTests { return identities } + @Test + func `merged menu width uses widest provider action set`() { + let settings = self.makeSettings() + settings.statusChecksEnabled = false + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let narrow = [ + MenuDescriptor.Section(entries: [ + .action("Usage Dashboard", .dashboard), + ]), + ] + let wide = [ + MenuDescriptor.Section(entries: [ + .action(String(repeating: "W", count: 60), .dashboard), + ]), + ] + + let narrowWidth = controller.measuredMenuCardWidth(for: [narrow]) + let stableWidth = controller.measuredMenuCardWidth(for: [narrow, wide]) + + #expect(narrowWidth == StatusItemController.menuCardBaseWidth) + #expect(stableWidth > narrowWidth) + #expect(controller.measuredMenuCardWidth(for: [wide, narrow]) == stableWidth) + } + + @Test + func `menu width normalization includes usage history submenu row`() { + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + settings.statusChecksEnabled = false + let controller = self.makeRecyclingController(settings: settings) + defer { controller.releaseStatusItemsForTesting() } + + let menu = NSMenu() + let usageHistoryItem = controller.makeMenuCardItem( + Text("Subscription Utilization"), + id: "usageHistorySubmenu", + width: StatusItemController.menuCardBaseWidth) + menu.addItem(usageHistoryItem) + menu.addItem(NSMenuItem( + title: String(repeating: "W", count: 60), + action: nil, + keyEquivalent: "")) + + let expectedWidth = controller.renderedMenuWidth(for: menu) + #expect(expectedWidth > StatusItemController.menuCardBaseWidth) + + controller.refreshMenuCardHeights(in: menu) + + #expect(abs((usageHistoryItem.view?.frame.width ?? 0) - expectedWidth) <= 0.5) + } + + @Test + func `rendered menu width keeps tracked window width after AppKit shrink`() { + let width = StatusItemController.resolvedRenderedMenuWidth( + menuWidth: 310, + trackedWindowWidth: 356) + + #expect(width == 356) + #expect(StatusItemController.resolvedRenderedMenuWidth( + menuWidth: 310, + trackedWindowWidth: nil) == 310) + } + @Test func `data only repopulate reuses menu card hosting views`() { StatusItemController.setMenuRefreshEnabledForTesting(false) From 02c94032c79a23b95658b37c2f85ea59d8de713a Mon Sep 17 00:00:00 2001 From: pickaxe <54486432+ProspectOre@users.noreply.github.com> Date: Wed, 10 Jun 2026 19:43:04 -0700 Subject: [PATCH 30/51] Decode provider status feeds off the main actor (#1406) * Decode provider status feeds off the main actor UsageStore's status fetch/parse helpers are statics on a MainActor type, so the Google Workspace incidents feed (hundreds of kilobytes live) decoded on the main thread, stalling the UI 150-340ms per Google-status provider per refresh - refreshes that also fire during menu interaction (#1399). The status helpers touch no store state, so they are now nonisolated and run on the concurrent executor, and the per-date-field ISO8601DateFormatter allocations are replaced with shared lock-guarded formatters (same pattern as CostUsageISO8601FormatterBox). * perf: guarantee status decoding stays off main --------- Co-authored-by: Peter Steinberger --- CHANGELOG.md | 1 + Sources/CodexBar/UsageStore+Status.swift | 82 +++++++++++++------ .../GoogleWorkspaceStatusNetworkTests.swift | 26 ++++++ 3 files changed, 82 insertions(+), 27 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f62670b7..2ac0eae4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ - Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra! - Menu bar: defer pasteboard writes and copy feedback outside the `NSMenu` tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405! - Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7! +- Provider status: decode status feeds on the concurrent executor and reuse ISO8601 formatters, removing a measured main-thread stall during refreshes (#1406). Thanks @ProspectOre! - Menu bar: keep one stable width across merged provider tabs and resize every hosted card row to AppKit's final menu width so provider switching no longer leaves a widened menu with inset submenu arrows (#1410). - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). - Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! diff --git a/Sources/CodexBar/UsageStore+Status.swift b/Sources/CodexBar/UsageStore+Status.swift index 4d1b85e4..c1bd9b3f 100644 --- a/Sources/CodexBar/UsageStore+Status.swift +++ b/Sources/CodexBar/UsageStore+Status.swift @@ -1,8 +1,51 @@ import CodexBarCore import Foundation +/// Shared, lock-guarded ISO8601 formatters for status feeds. Allocating a fresh +/// `ISO8601DateFormatter` per decoded date field is a measurable share of decoding the +/// Google Workspace incidents feed, which can run to hundreds of kilobytes (#1399). +private final class StatusISO8601FormatterBox: @unchecked Sendable { + let lock = NSLock() + let withFractional: ISO8601DateFormatter = { + let fmt = ISO8601DateFormatter() + fmt.formatOptions = [.withInternetDateTime, .withFractionalSeconds] + return fmt + }() + + let plain: ISO8601DateFormatter = { + let fmt = ISO8601DateFormatter() + fmt.formatOptions = [.withInternetDateTime] + return fmt + }() +} + +private enum StatusFeedDateParser { + static let box = StatusISO8601FormatterBox() + + static func parse(_ text: String) -> Date? { + self.box.lock.lock() + defer { self.box.lock.unlock() } + return self.box.withFractional.date(from: text) ?? self.box.plain.date(from: text) + } + + static func decodingStrategy() -> JSONDecoder.DateDecodingStrategy { + .custom { decoder in + let container = try decoder.singleValueContainer() + let raw = try container.decode(String.self) + guard let date = StatusFeedDateParser.parse(raw) else { + throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date") + } + return date + } + } +} + extension UsageStore { - static func fetchStatus( + /// Status feeds decode off the main actor: the Google Workspace incidents payload alone + /// can be hundreds of kilobytes and cost 150-340ms to decode (#1399), and these helpers + /// touch no store state. + @concurrent + nonisolated static func fetchStatus( from baseURL: URL, transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> ProviderStatus @@ -32,16 +75,7 @@ extension UsageStore { } let decoder = JSONDecoder() - decoder.dateDecodingStrategy = .custom { decoder in - let container = try decoder.singleValueContainer() - let raw = try container.decode(String.self) - let formatter = ISO8601DateFormatter() - formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds] - if let date = formatter.date(from: raw) { return date } - formatter.formatOptions = [.withInternetDateTime] - if let date = formatter.date(from: raw) { return date } - throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date") - } + decoder.dateDecodingStrategy = StatusFeedDateParser.decodingStrategy() let response = try decoder.decode(Response.self, from: data) let indicator = ProviderStatusIndicator(rawValue: response.status.indicator) ?? .unknown @@ -51,9 +85,11 @@ extension UsageStore { updatedAt: response.page?.updatedAt) } - static func fetchWorkspaceStatus( + @concurrent + nonisolated static func fetchWorkspaceStatus( productID: String, - transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) + transport: any ProviderHTTPTransport = ProviderHTTPClient.shared, + beforeDecoding: (@Sendable () -> Void)? = nil) async throws -> ProviderStatus { guard let url = URL(string: "https://www.google.com/appsstatus/dashboard/incidents.json") else { @@ -62,22 +98,14 @@ extension UsageStore { var request = URLRequest(url: url) request.timeoutInterval = 10 let (data, _) = try await transport.data(for: request) + beforeDecoding?() return try Self.parseGoogleWorkspaceStatus(data: data, productID: productID) } - static func parseGoogleWorkspaceStatus(data: Data, productID: String) throws -> ProviderStatus { + nonisolated static func parseGoogleWorkspaceStatus(data: Data, productID: String) throws -> ProviderStatus { let decoder = JSONDecoder() decoder.keyDecodingStrategy = .convertFromSnakeCase - decoder.dateDecodingStrategy = .custom { decoder in - let container = try decoder.singleValueContainer() - let raw = try container.decode(String.self) - let formatter = ISO8601DateFormatter() - formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds] - if let date = formatter.date(from: raw) { return date } - formatter.formatOptions = [.withInternetDateTime] - if let date = formatter.date(from: raw) { return date } - throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid ISO8601 date") - } + decoder.dateDecodingStrategy = StatusFeedDateParser.decodingStrategy() let incidents = try decoder.decode([GoogleWorkspaceIncident].self, from: data) let active = incidents.filter { $0.isRelevant(productID: productID) && $0.isActive } @@ -105,7 +133,7 @@ extension UsageStore { return ProviderStatus(indicator: best.indicator, description: description, updatedAt: updatedAt) } - private static func indicatorRank(_ indicator: ProviderStatusIndicator) -> Int { + private nonisolated static func indicatorRank(_ indicator: ProviderStatusIndicator) -> Int { switch indicator { case .none: 0 case .maintenance: 1 @@ -116,7 +144,7 @@ extension UsageStore { } } - private static func workspaceIndicator(status: String?, severity: String?) -> ProviderStatusIndicator { + private nonisolated static func workspaceIndicator(status: String?, severity: String?) -> ProviderStatusIndicator { switch status?.uppercased() { case "AVAILABLE": return .none case "SERVICE_INFORMATION": return .minor @@ -134,7 +162,7 @@ extension UsageStore { } } - private static func workspaceSummary(from text: String?) -> String? { + private nonisolated static func workspaceSummary(from text: String?) -> String? { guard let text else { return nil } let normalized = text .replacingOccurrences(of: "\r\n", with: "\n") diff --git a/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift b/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift index 92661272..1d51d3df 100644 --- a/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift +++ b/Tests/CodexBarTests/GoogleWorkspaceStatusNetworkTests.swift @@ -1,4 +1,5 @@ import Foundation +import os import Testing @testable import CodexBar @@ -41,4 +42,29 @@ struct GoogleWorkspaceStatusNetworkTests { #expect(requests.count == 1) #expect(requests.first?.url?.host == "www.google.com") } + + @Test + func `fetchWorkspaceStatus decodes off the main thread when called from the main actor`() async throws { + // The incidents feed can run to hundreds of kilobytes; decoding it on the main + // actor stalls the UI for 150-340ms per Google-status provider per refresh (#1399). + let decodedOffMainThread = OSAllocatedUnfairLock(initialState: false) + let transport = ProviderHTTPTransportStub { request in + let response = try HTTPURLResponse( + url: #require(request.url), + statusCode: 200, + httpVersion: "HTTP/1.1", + headerFields: ["Content-Type": "application/json"])! + return (Data("[]".utf8), response) + } + + let status = try await UsageStore.fetchWorkspaceStatus( + productID: "npdyhgECDJ6tB66MxXyo", + transport: transport, + beforeDecoding: { + decodedOffMainThread.withLock { $0 = !Thread.isMainThread } + }) + + #expect(status.indicator == .none) + #expect(decodedOffMainThread.withLock { $0 }) + } } From ad71da06985e65ab2664594602f09e2dcaa94a1d Mon Sep 17 00:00:00 2001 From: pickaxe <54486432+ProspectOre@users.noreply.github.com> Date: Wed, 10 Jun 2026 12:30:49 -0700 Subject: [PATCH 31/51] Keep codex account file reads off the menu-build path populateMenu -> codexAccountMenuDisplay loaded the codex account reconciliation snapshot synchronously whenever the 2s freshness cache had lapsed, paying auth.json reads, JWT parsing, and SHA256 fingerprinting on the main thread inside menu open and tracking. Menu display now tolerates a stale cached snapshot and revalidates the cache off the menu-build path; account changes land on the next rebuild. --- CHANGELOG.md | 1 + .../Providers/Codex/CodexSettingsStore.swift | 39 ++++++ Sources/CodexBar/SettingsStore.swift | 1 + ...tusItemController+AccountMenuDisplay.swift | 2 +- ...CodexAccountMenuDisplaySnapshotTests.swift | 114 ++++++++++++++++++ 5 files changed, 156 insertions(+), 1 deletion(-) create mode 100644 Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ac0eae4..a578f899 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ - Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7! - Provider status: decode status feeds on the concurrent executor and reuse ISO8601 formatters, removing a measured main-thread stall during refreshes (#1406). Thanks @ProspectOre! - Menu bar: keep one stable width across merged provider tabs and resize every hosted card row to AppKit's final menu width so provider switching no longer leaves a widened menu with inset submenu arrows (#1410). +- Menu bar: keep Codex `auth.json` reads, JWT parsing, and fingerprint hashing off the menu-build path by rendering a cached account snapshot and revalidating it asynchronously (#1401). Thanks @ProspectOre! - Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325). - Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial! - Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl! diff --git a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift index 1f7987b1..b7d2650e 100644 --- a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift +++ b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift @@ -240,10 +240,49 @@ extension SettingsStore { return snapshot } + /// Menu rendering must not block on live `auth.json` reads, JWT parsing, and fingerprint + /// hashing. This returns the cached reconciliation snapshot even when it is older than the + /// freshness interval and refreshes the cache off the menu-build path instead, so only the + /// first menu build after launch (no cache yet) or an active-source change pays the + /// synchronous load. Account changes land on the next menu rebuild. + var codexAccountReconciliationSnapshotForMenuDisplay: CodexAccountReconciliationSnapshot { + let activeSource = self.codexPersistedActiveSource + guard Self.codexAccountReconciliationSnapshotCacheInterval > 0, + let cached = self.cachedCodexAccountReconciliationSnapshot, + cached.activeSource == activeSource + else { + return self.codexAccountReconciliationSnapshot(activeSourceOverride: nil) + } + if Date().timeIntervalSince(cached.loadedAt) >= Self.codexAccountReconciliationSnapshotCacheInterval { + self.scheduleCodexAccountReconciliationSnapshotRevalidation() + } + return cached.snapshot + } + + private func scheduleCodexAccountReconciliationSnapshotRevalidation() { + guard self.codexAccountSnapshotRevalidationTask == nil else { return } + self.codexAccountSnapshotRevalidationTask = Task { @MainActor [weak self] in + // The main dispatch queue does not drain while AppKit runs the menu-tracking run loop + // mode, so this hop keeps the reload from landing inside an open tracking session. + await withCheckedContinuation { continuation in + DispatchQueue.main.async { continuation.resume() } + } + guard let self else { return } + defer { self.codexAccountSnapshotRevalidationTask = nil } + guard !Task.isCancelled else { return } + self.invalidateCodexAccountReconciliationSnapshotCache() + _ = self.codexAccountReconciliationSnapshot(activeSourceOverride: nil) + } + } + var codexVisibleAccountProjection: CodexVisibleAccountProjection { CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshot) } + var codexVisibleAccountProjectionForMenuDisplay: CodexVisibleAccountProjection { + CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshotForMenuDisplay) + } + var codexVisibleAccounts: [CodexVisibleAccount] { self.codexVisibleAccountProjection.visibleAccounts } diff --git a/Sources/CodexBar/SettingsStore.swift b/Sources/CodexBar/SettingsStore.swift index c6135391..6bf989c2 100644 --- a/Sources/CodexBar/SettingsStore.swift +++ b/Sources/CodexBar/SettingsStore.swift @@ -140,6 +140,7 @@ final class SettingsStore { @ObservationIgnored var tokenAccountsLoaded = false @ObservationIgnored var cachedCodexAccountReconciliationSnapshot: CachedCodexAccountReconciliationSnapshot? + @ObservationIgnored var codexAccountSnapshotRevalidationTask: Task? @ObservationIgnored var mergedMenuLastSelectedWasOverviewStorage = false @ObservationIgnored var selectedMenuProviderRawStorage: String? var defaultsState: SettingsDefaultsState diff --git a/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift index ea0bb9d2..824d5e0c 100644 --- a/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift +++ b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift @@ -35,7 +35,7 @@ extension StatusItemController { func codexAccountMenuDisplay(for provider: UsageProvider) -> CodexAccountMenuDisplay? { guard provider == .codex else { return nil } - let projection = self.settings.codexVisibleAccountProjection + let projection = self.settings.codexVisibleAccountProjectionForMenuDisplay guard projection.visibleAccounts.count > 1 else { return nil } let showAll = self.settings.multiAccountMenuLayout == .stacked let accounts = showAll diff --git a/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift new file mode 100644 index 00000000..891b0d4c --- /dev/null +++ b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift @@ -0,0 +1,114 @@ +import CodexBarCore +import Foundation +import Testing +@testable import CodexBar + +@Suite(.serialized) +struct CodexAccountMenuDisplaySnapshotTests { + @MainActor + private static func makeSettings(suite: String) throws -> SettingsStore { + let defaults = try #require(UserDefaults(suiteName: suite)) + defaults.removePersistentDomain(forName: suite) + defaults.set(true, forKey: "providerDetectionCompleted") + let settings = SettingsStore( + userDefaults: defaults, + configStore: testConfigStore(suiteName: suite), + zaiTokenStore: NoopZaiTokenStore(), + syntheticTokenStore: NoopSyntheticTokenStore()) + settings.providerDetectionCompleted = true + return settings + } + + private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws { + try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true) + let auth = ["tokens": [ + "accessToken": "access-token", + "refreshToken": "refresh-token", + "idToken": Self.fakeJWT(email: email, plan: plan), + ]] + let data = try JSONSerialization.data(withJSONObject: auth) + try data.write(to: homeURL.appendingPathComponent("auth.json")) + } + + private static func fakeJWT(email: String, plan: String) -> String { + let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data() + let payload = (try? JSONSerialization.data(withJSONObject: [ + "email": email, + "chatgpt_plan_type": plan, + ])) ?? Data() + + func base64URL(_ data: Data) -> String { + data.base64EncodedString() + .replacingOccurrences(of: "=", with: "") + .replacingOccurrences(of: "+", with: "-") + .replacingOccurrences(of: "/", with: "_") + } + + return "\(base64URL(header)).\(base64URL(payload))." + } + + @Test + @MainActor + func `menu display snapshot tolerates stale cache and revalidates off the menu path`() async throws { + let suite = "CodexAccountMenuDisplaySnapshotTests-stale-cache" + let settings = try Self.makeSettings(suite: suite) + let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent( + UUID().uuidString, + isDirectory: true) + try Self.writeCodexAuthFile(homeURL: ambientHome, email: "before@example.com", plan: "pro") + settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path] + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60 + defer { + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil + settings._test_codexReconciliationEnvironment = nil + try? FileManager.default.removeItem(at: ambientHome) + } + + let primed = settings.codexAccountReconciliationSnapshot + #expect(primed.liveSystemAccount?.email == "before@example.com") + + // Simulate a cache that has outlived the freshness interval while the auth file changed. + try Self.writeCodexAuthFile(homeURL: ambientHome, email: "after@example.com", plan: "pro") + let cached = try #require(settings.cachedCodexAccountReconciliationSnapshot) + settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot( + activeSource: cached.activeSource, + loadedAt: Date(timeIntervalSinceNow: -3600), + snapshot: cached.snapshot) + + // The menu path returns the stale cache without a synchronous reload. + let menuSnapshot = settings.codexAccountReconciliationSnapshotForMenuDisplay + #expect(menuSnapshot.liveSystemAccount?.email == "before@example.com") + + // The scheduled revalidation refreshes the cache off the menu path. + let revalidation = try #require(settings.codexAccountSnapshotRevalidationTask) + await revalidation.value + #expect(settings.codexAccountSnapshotRevalidationTask == nil) + #expect( + settings.codexAccountReconciliationSnapshotForMenuDisplay.liveSystemAccount?.email == + "after@example.com") + } + + @Test + @MainActor + func `menu display snapshot loads synchronously without a cache`() throws { + let suite = "CodexAccountMenuDisplaySnapshotTests-cold-cache" + let settings = try Self.makeSettings(suite: suite) + let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent( + UUID().uuidString, + isDirectory: true) + try Self.writeCodexAuthFile(homeURL: ambientHome, email: "cold@example.com", plan: "pro") + settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path] + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60 + defer { + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil + settings._test_codexReconciliationEnvironment = nil + try? FileManager.default.removeItem(at: ambientHome) + } + + #expect(settings.cachedCodexAccountReconciliationSnapshot == nil) + let menuSnapshot = settings.codexAccountReconciliationSnapshotForMenuDisplay + #expect(menuSnapshot.liveSystemAccount?.email == "cold@example.com") + #expect(settings.codexAccountSnapshotRevalidationTask == nil) + #expect(settings.cachedCodexAccountReconciliationSnapshot != nil) + } +} From f1c1b6cdf3eadaa8cfd0ba15aa99c78bfe3c08bc Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 04:08:32 +0100 Subject: [PATCH 32/51] perf: keep Codex account reconciliation off menu tracking --- .../Providers/Codex/CodexSettingsStore.swift | 130 ++++-- Sources/CodexBar/SettingsStore.swift | 20 +- ...tusItemController+AccountMenuDisplay.swift | 51 ++- .../CodexBar/StatusItemController+Menu.swift | 2 + .../StatusItemController+MenuTracking.swift | 6 +- .../StatusItemController+Shutdown.swift | 2 + Sources/CodexBar/StatusItemController.swift | 3 + .../Codex/CodexAccountReconciliation.swift | 2 +- ...CodexAccountMenuDisplaySnapshotTests.swift | 376 ++++++++++++++---- .../StatusMenuCodexSwitcherTests.swift | 3 + 10 files changed, 476 insertions(+), 119 deletions(-) diff --git a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift index b7d2650e..a0be2ddb 100644 --- a/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift +++ b/Sources/CodexBar/Providers/Codex/CodexSettingsStore.swift @@ -141,6 +141,7 @@ extension SettingsStore { } set { self.invalidateCodexAccountReconciliationSnapshotCache() + self.cachedCodexAccountMenuProjection = nil self.updateProviderConfig(provider: .codex) { entry in entry.codexActiveSource = newValue } @@ -166,6 +167,7 @@ extension SettingsStore { @discardableResult func refreshCodexAccountReconciliationAfterManagedAccountsDidChange() -> Bool { self.invalidateCodexAccountReconciliationSnapshotCache() + self.cachedCodexAccountMenuProjection = nil return self.persistResolvedCodexActiveSourceCorrectionIfNeeded() } @@ -210,6 +212,7 @@ extension SettingsStore { func invalidateCodexAccountReconciliationSnapshotCache() { self.cachedCodexAccountReconciliationSnapshot = nil + self.codexAccountReconciliationGeneration &+= 1 } var codexAccountReconciliationSnapshot: CodexAccountReconciliationSnapshot { @@ -230,57 +233,86 @@ extension SettingsStore { return cached.snapshot } - let snapshot = self.codexAccountReconciler(activeSource: activeSource).loadSnapshot() + let snapshot = self.codexAccountSnapshotLoader(activeSource: activeSource)() + let loadedAt = Date() if cacheInterval > 0 { self.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot( activeSource: activeSource, - loadedAt: now, + loadedAt: loadedAt, snapshot: snapshot) } + if activeSource == self.codexPersistedActiveSource { + self.cachedCodexAccountMenuProjection = CachedCodexAccountMenuProjection( + activeSource: activeSource, + loadedAt: loadedAt, + projection: CodexVisibleAccountProjection.make(from: snapshot)) + } return snapshot } - /// Menu rendering must not block on live `auth.json` reads, JWT parsing, and fingerprint - /// hashing. This returns the cached reconciliation snapshot even when it is older than the - /// freshness interval and refreshes the cache off the menu-build path instead, so only the - /// first menu build after launch (no cache yet) or an active-source change pays the - /// synchronous load. Account changes land on the next menu rebuild. - var codexAccountReconciliationSnapshotForMenuDisplay: CodexAccountReconciliationSnapshot { + /// Menu rendering must stay side-effect free: no `auth.json` reads, JWT parsing, or fingerprint hashing. + var codexVisibleAccountProjectionForMenuDisplay: CodexVisibleAccountProjection? { let activeSource = self.codexPersistedActiveSource - guard Self.codexAccountReconciliationSnapshotCacheInterval > 0, - let cached = self.cachedCodexAccountReconciliationSnapshot, + guard let cached = self.cachedCodexAccountMenuProjection, cached.activeSource == activeSource else { - return self.codexAccountReconciliationSnapshot(activeSourceOverride: nil) + return nil } - if Date().timeIntervalSince(cached.loadedAt) >= Self.codexAccountReconciliationSnapshotCacheInterval { - self.scheduleCodexAccountReconciliationSnapshotRevalidation() + return cached.projection + } + + var codexAccountMenuProjectionNeedsRevalidation: Bool { + let activeSource = self.codexPersistedActiveSource + guard let cached = self.cachedCodexAccountMenuProjection, + cached.activeSource == activeSource + else { + return true } - return cached.snapshot + return Date().timeIntervalSince(cached.loadedAt) >= Self.codexAccountReconciliationSnapshotCacheInterval } - private func scheduleCodexAccountReconciliationSnapshotRevalidation() { - guard self.codexAccountSnapshotRevalidationTask == nil else { return } - self.codexAccountSnapshotRevalidationTask = Task { @MainActor [weak self] in - // The main dispatch queue does not drain while AppKit runs the menu-tracking run loop - // mode, so this hop keeps the reload from landing inside an open tracking session. - await withCheckedContinuation { continuation in - DispatchQueue.main.async { continuation.resume() } - } - guard let self else { return } - defer { self.codexAccountSnapshotRevalidationTask = nil } - guard !Task.isCancelled else { return } - self.invalidateCodexAccountReconciliationSnapshotCache() - _ = self.codexAccountReconciliationSnapshot(activeSourceOverride: nil) + func revalidateCodexAccountMenuProjection() async -> CodexAccountMenuProjectionRevalidationResult { + guard self.codexAccountMenuProjectionNeedsRevalidation else { return .skipped } + + let activeSource = self.codexPersistedActiveSource + let generation = self.codexAccountReconciliationGeneration + let loader = self.codexAccountSnapshotLoader(activeSource: activeSource) + let snapshot = await Self.loadCodexAccountSnapshot(loader) + + guard generation == self.codexAccountReconciliationGeneration, + activeSource == self.codexPersistedActiveSource + else { + return .discarded + } + + let now = Date() + let projection = CodexVisibleAccountProjection.make(from: snapshot) + let previousProjection = self.cachedCodexAccountMenuProjection.flatMap { cached in + cached.activeSource == activeSource ? cached.projection : nil + } + self.cachedCodexAccountMenuProjection = CachedCodexAccountMenuProjection( + activeSource: activeSource, + loadedAt: now, + projection: projection) + if Self.codexAccountReconciliationSnapshotCacheInterval > 0 { + self.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot( + activeSource: activeSource, + loadedAt: now, + snapshot: snapshot) } + return previousProjection == projection ? .unchanged : .updated } - var codexVisibleAccountProjection: CodexVisibleAccountProjection { - CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshot) + @concurrent + private nonisolated static func loadCodexAccountSnapshot( + _ loader: @escaping @Sendable () -> CodexAccountReconciliationSnapshot) + async -> CodexAccountReconciliationSnapshot + { + loader() } - var codexVisibleAccountProjectionForMenuDisplay: CodexVisibleAccountProjection { - CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshotForMenuDisplay) + var codexVisibleAccountProjection: CodexVisibleAccountProjection { + CodexVisibleAccountProjection.make(from: self.codexAccountReconciliationSnapshot) } var codexVisibleAccounts: [CodexVisibleAccount] { @@ -296,11 +328,8 @@ extension SettingsStore { } func selectDisplayedCodexVisibleAccount(_ account: CodexVisibleAccount) { - if self.selectCodexVisibleAccount(id: account.id) { - return - } - // An open menu can preserve a previously rendered account row while the live projection is briefly incomplete. - self.invalidateCodexAccountReconciliationSnapshotCache() + // The row already carries the exact source it represented. Re-resolving its ID would synchronously + // reload auth state from the menu click callback and can also fail after a stale snapshot is rendered. self.codexActiveSource = account.selectionSource } @@ -322,6 +351,18 @@ extension SettingsStore { self.codexVisibleAccountProjection.source(forVisibleAccountID: id) } + private func codexAccountSnapshotLoader( + activeSource: CodexActiveSource) -> @Sendable () -> CodexAccountReconciliationSnapshot + { + #if DEBUG + if let loader = self._test_codexAccountSnapshotLoader { + return { loader(activeSource) } + } + #endif + let reconciler = self.codexAccountReconciler(activeSource: activeSource) + return { reconciler.loadSnapshot() } + } + private func codexAccountReconciler(activeSource: CodexActiveSource) -> DefaultCodexAccountReconciler { let baseEnvironment = self.codexReconciliationEnvironment() #if DEBUG @@ -557,10 +598,15 @@ private struct CodexManagedRemoteHomeTestingSystemObserver: CodexSystemAccountOb } extension SettingsStore { + private func invalidateCodexAccountReconciliationCachesForTesting() { + self.invalidateCodexAccountReconciliationSnapshotCache() + self.cachedCodexAccountMenuProjection = nil + } + var _test_activeManagedCodexRemoteHomePath: String? { get { CodexManagedRemoteHomeTestingOverride.homePath(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setHomePath(newValue, for: self) } } @@ -568,7 +614,7 @@ extension SettingsStore { var _test_activeManagedCodexAccount: ManagedCodexAccount? { get { CodexManagedRemoteHomeTestingOverride.account(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setAccount(newValue, for: self) } } @@ -576,7 +622,7 @@ extension SettingsStore { var _test_unreadableManagedCodexAccountStore: Bool { get { CodexManagedRemoteHomeTestingOverride.isUnreadable(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setUnreadable(newValue, for: self) } } @@ -584,7 +630,7 @@ extension SettingsStore { var _test_managedCodexAccountStoreURL: URL? { get { CodexManagedRemoteHomeTestingOverride.managedStoreURL(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setManagedStoreURL(newValue, for: self) } } @@ -592,7 +638,7 @@ extension SettingsStore { var _test_liveSystemCodexAccount: ObservedSystemCodexAccount? { get { CodexManagedRemoteHomeTestingOverride.liveSystemAccount(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setLiveSystemAccount(newValue, for: self) } } @@ -600,7 +646,7 @@ extension SettingsStore { var _test_codexReconciliationEnvironment: [String: String]? { get { CodexManagedRemoteHomeTestingOverride.reconciliationEnvironment(for: self) } set { - self.invalidateCodexAccountReconciliationSnapshotCache() + self.invalidateCodexAccountReconciliationCachesForTesting() CodexManagedRemoteHomeTestingOverride.setReconciliationEnvironment(newValue, for: self) } } diff --git a/Sources/CodexBar/SettingsStore.swift b/Sources/CodexBar/SettingsStore.swift index 6bf989c2..7a05a305 100644 --- a/Sources/CodexBar/SettingsStore.swift +++ b/Sources/CodexBar/SettingsStore.swift @@ -114,6 +114,19 @@ struct CachedCodexAccountReconciliationSnapshot { let snapshot: CodexAccountReconciliationSnapshot } +struct CachedCodexAccountMenuProjection: Equatable { + let activeSource: CodexActiveSource + let loadedAt: Date + let projection: CodexVisibleAccountProjection +} + +enum CodexAccountMenuProjectionRevalidationResult: Equatable { + case skipped + case discarded + case unchanged + case updated +} + @MainActor @Observable final class SettingsStore { @@ -140,7 +153,12 @@ final class SettingsStore { @ObservationIgnored var tokenAccountsLoaded = false @ObservationIgnored var cachedCodexAccountReconciliationSnapshot: CachedCodexAccountReconciliationSnapshot? - @ObservationIgnored var codexAccountSnapshotRevalidationTask: Task? + @ObservationIgnored var cachedCodexAccountMenuProjection: CachedCodexAccountMenuProjection? + @ObservationIgnored var codexAccountReconciliationGeneration: UInt = 0 + #if DEBUG + @ObservationIgnored var _test_codexAccountSnapshotLoader: + (@Sendable (CodexActiveSource) -> CodexAccountReconciliationSnapshot)? + #endif @ObservationIgnored var mergedMenuLastSelectedWasOverviewStorage = false @ObservationIgnored var selectedMenuProviderRawStorage: String? var defaultsState: SettingsDefaultsState diff --git a/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift index 824d5e0c..2c268511 100644 --- a/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift +++ b/Sources/CodexBar/StatusItemController+AccountMenuDisplay.swift @@ -2,6 +2,30 @@ import AppKit import CodexBarCore extension StatusItemController { + private static let defaultCodexAccountMenuProjectionRevalidationEnabled = !SettingsStore.isRunningTests + + #if DEBUG + private static var codexAccountMenuProjectionRevalidationEnabledForTesting = + defaultCodexAccountMenuProjectionRevalidationEnabled + + static func setCodexAccountMenuProjectionRevalidationEnabledForTesting(_ enabled: Bool) { + self.codexAccountMenuProjectionRevalidationEnabledForTesting = enabled + } + + static func resetCodexAccountMenuProjectionRevalidationEnabledForTesting() { + self.codexAccountMenuProjectionRevalidationEnabledForTesting = + self.defaultCodexAccountMenuProjectionRevalidationEnabled + } + #endif + + private static var codexAccountMenuProjectionRevalidationEnabled: Bool { + #if DEBUG + self.codexAccountMenuProjectionRevalidationEnabledForTesting + #else + self.defaultCodexAccountMenuProjectionRevalidationEnabled + #endif + } + func tokenAccountMenuDisplay(for provider: UsageProvider) -> TokenAccountMenuDisplay? { guard TokenAccountSupportCatalog.support(for: provider) != nil else { return nil } let accounts = self.settings.tokenAccounts(for: provider) @@ -35,7 +59,7 @@ extension StatusItemController { func codexAccountMenuDisplay(for provider: UsageProvider) -> CodexAccountMenuDisplay? { guard provider == .codex else { return nil } - let projection = self.settings.codexVisibleAccountProjectionForMenuDisplay + guard let projection = self.settings.codexVisibleAccountProjectionForMenuDisplay else { return nil } guard projection.visibleAccounts.count > 1 else { return nil } let showAll = self.settings.multiAccountMenuLayout == .stacked let accounts = showAll @@ -52,6 +76,31 @@ extension StatusItemController { layout: showAll ? .stacked : .segmented) } + func scheduleCodexAccountMenuProjectionRevalidationIfNeeded(for providers: [UsageProvider]) { + guard Self.codexAccountMenuProjectionRevalidationEnabled else { return } + guard providers.contains(.codex) else { return } + guard self.settings.codexAccountMenuProjectionNeedsRevalidation else { return } + guard self.codexAccountMenuProjectionRevalidationTask == nil else { return } + + self.codexAccountMenuProjectionRevalidationTask = Task { @MainActor [weak self] in + guard let settings = self?.settings else { return } + let result = await settings.revalidateCodexAccountMenuProjection() + guard let self else { return } + guard !Task.isCancelled else { + self.codexAccountMenuProjectionRevalidationTask = nil + return + } + self.codexAccountMenuProjectionRevalidationTask = nil + + switch result { + case .updated: + self.invalidateMenus(refreshOpenMenus: false) + case .discarded, .skipped, .unchanged: + break + } + } + } + private func codexAccountSnapshots(matching accounts: [CodexVisibleAccount]) -> [CodexAccountUsageSnapshot] { var snapshotsByID: [String: CodexAccountUsageSnapshot] = [:] for snapshot in self.store.codexAccountSnapshots { diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift index 2e4f9c52..d1a491b7 100644 --- a/Sources/CodexBar/StatusItemController+Menu.swift +++ b/Sources/CodexBar/StatusItemController+Menu.swift @@ -121,6 +121,8 @@ extension StatusItemController { let menuWasFreshBeforeOpen = !self.menuNeedsRefresh(menu) self.refreshMenuForOpenIfNeeded(menu, provider: provider) + self.scheduleCodexAccountMenuProjectionRevalidationIfNeeded( + for: self.renderedProviders(for: menu)) if self.isMenuRefreshEnabled { // Intentionally skip open-menu tracking when refresh is disabled (tests). // If refresh is re-enabled while this menu stays open, it will not be backfilled until next open. diff --git a/Sources/CodexBar/StatusItemController+MenuTracking.swift b/Sources/CodexBar/StatusItemController+MenuTracking.swift index f7acd4a4..7601eeb0 100644 --- a/Sources/CodexBar/StatusItemController+MenuTracking.swift +++ b/Sources/CodexBar/StatusItemController+MenuTracking.swift @@ -303,7 +303,7 @@ extension StatusItemController { parts.append(target.rawValue) parts.append(self.providerIdentitySignature(self.store.snapshot(for: target)?.identity(for: target))) - if self.store.metadata(for: target).usesAccountFallback { + if target != .codex, self.store.metadata(for: target).usesAccountFallback { let account = self.store.accountInfo(for: target) parts.append(Self.menuIdentityField(account.email)) parts.append(Self.menuIdentityField(account.plan)) @@ -316,7 +316,9 @@ extension StatusItemController { } if target == .codex { - for account in self.settings.codexVisibleAccountProjection.visibleAccounts { + parts.append(Self.menuIdentityField(self.account.email)) + parts.append(Self.menuIdentityField(self.account.plan)) + for account in self.settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts ?? [] { parts.append(Self.menuIdentityField(account.id)) parts.append(Self.menuIdentityField(account.email)) parts.append(Self.menuIdentityField(account.workspaceLabel)) diff --git a/Sources/CodexBar/StatusItemController+Shutdown.swift b/Sources/CodexBar/StatusItemController+Shutdown.swift index 5ca3f397..6494086c 100644 --- a/Sources/CodexBar/StatusItemController+Shutdown.swift +++ b/Sources/CodexBar/StatusItemController+Shutdown.swift @@ -52,6 +52,8 @@ extension StatusItemController { } self.openMenuInvalidationRetryTask?.cancel() self.openMenuInvalidationRetryTask = nil + self.codexAccountMenuProjectionRevalidationTask?.cancel() + self.codexAccountMenuProjectionRevalidationTask = nil self.providerSelectionUIRefreshTask?.cancel() self.providerSelectionUIRefreshTask = nil self.deferredMergedIconRenderAfterTracking = false diff --git a/Sources/CodexBar/StatusItemController.swift b/Sources/CodexBar/StatusItemController.swift index ca719199..60ad9d55 100644 --- a/Sources/CodexBar/StatusItemController.swift +++ b/Sources/CodexBar/StatusItemController.swift @@ -139,6 +139,7 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin var openMenuRebuildTokens: [ObjectIdentifier: Int] = [:] var openMenuRebuildTokenCounter = 0 var menuIdentitySignatures: [ObjectIdentifier: String] = [:] + var codexAccountMenuProjectionRevalidationTask: Task? var openMenuRebuildsClosingHostedSubviewMenus: Set = [] var parentMenuRebuildsDeferredDuringTracking: Set = [] var deferredMenuInteractionRefreshProviders: Set = [] @@ -415,6 +416,8 @@ final class StatusItemController: NSObject, NSMenuDelegate, StatusItemControllin self.wireBindings() self.updateVisibility() self.updateIcons() + self.scheduleCodexAccountMenuProjectionRevalidationIfNeeded( + for: self.store.enabledProvidersForDisplay()) self.scheduleStartupStatusItemVisibilityCheck() NotificationCenter.default.addObserver( self, diff --git a/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift b/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift index 25dcae7a..3b2f8a07 100644 --- a/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift +++ b/Sources/CodexBarCore/Providers/Codex/CodexAccountReconciliation.swift @@ -119,7 +119,7 @@ public struct CodexAccountReconciliationSnapshot: Equatable, Sendable { } } -public struct DefaultCodexAccountReconciler { +public struct DefaultCodexAccountReconciler: Sendable { public let storeLoader: @Sendable () throws -> ManagedCodexAccountSet public let systemObserver: any CodexSystemAccountObserving public let activeSource: CodexActiveSource diff --git a/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift index 891b0d4c..5941c8b0 100644 --- a/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift +++ b/Tests/CodexBarTests/CodexAccountMenuDisplaySnapshotTests.swift @@ -1,13 +1,15 @@ +import AppKit import CodexBarCore import Foundation import Testing @testable import CodexBar @Suite(.serialized) +@MainActor struct CodexAccountMenuDisplaySnapshotTests { - @MainActor - private static func makeSettings(suite: String) throws -> SettingsStore { - let defaults = try #require(UserDefaults(suiteName: suite)) + private func makeSettings() -> SettingsStore { + let suite = "CodexAccountMenuDisplaySnapshotTests-\(UUID().uuidString)" + let defaults = UserDefaults(suiteName: suite)! defaults.removePersistentDomain(forName: suite) defaults.set(true, forKey: "providerDetectionCompleted") let settings = SettingsStore( @@ -19,96 +21,326 @@ struct CodexAccountMenuDisplaySnapshotTests { return settings } - private static func writeCodexAuthFile(homeURL: URL, email: String, plan: String) throws { - try FileManager.default.createDirectory(at: homeURL, withIntermediateDirectories: true) - let auth = ["tokens": [ - "accessToken": "access-token", - "refreshToken": "refresh-token", - "idToken": Self.fakeJWT(email: email, plan: plan), - ]] - let data = try JSONSerialization.data(withJSONObject: auth) - try data.write(to: homeURL.appendingPathComponent("auth.json")) - } - - private static func fakeJWT(email: String, plan: String) -> String { - let header = (try? JSONSerialization.data(withJSONObject: ["alg": "none"])) ?? Data() - let payload = (try? JSONSerialization.data(withJSONObject: [ - "email": email, - "chatgpt_plan_type": plan, - ])) ?? Data() - - func base64URL(_ data: Data) -> String { - data.base64EncodedString() - .replacingOccurrences(of: "=", with: "") - .replacingOccurrences(of: "+", with: "-") - .replacingOccurrences(of: "/", with: "_") + private func enableOnlyCodex(_ settings: SettingsStore) { + for provider in UsageProvider.allCases { + guard let metadata = ProviderRegistry.shared.metadata[provider] else { continue } + settings.setProviderEnabled(provider: provider, metadata: metadata, enabled: provider == .codex) } + } + + private func liveSnapshot(email: String) -> CodexAccountReconciliationSnapshot { + CodexAccountReconciliationSnapshot( + storedAccounts: [], + activeStoredAccount: nil, + liveSystemAccount: ObservedSystemCodexAccount( + email: email, + codexHomePath: "/tmp/\(email)", + observedAt: Date()), + matchingStoredAccountForLiveSystemAccount: nil, + activeSource: .liveSystem, + hasUnreadableAddedAccountStore: false) + } + + private func cachedProjection( + snapshot: CodexAccountReconciliationSnapshot, + loadedAt: Date = Date(timeIntervalSinceNow: -3600)) -> CachedCodexAccountMenuProjection + { + CachedCodexAccountMenuProjection( + activeSource: snapshot.activeSource, + loadedAt: loadedAt, + projection: CodexVisibleAccountProjection.make(from: snapshot)) + } + + @Test + func `cold menu projection read never loads auth state`() async { + let settings = self.makeSettings() + let probe = CodexAccountSnapshotLoaderProbe(snapshot: self.liveSnapshot(email: "loaded@example.com")) + settings._test_codexAccountSnapshotLoader = { _ in probe.load() } + defer { settings._test_codexAccountSnapshotLoader = nil } + + #expect(settings.codexVisibleAccountProjectionForMenuDisplay == nil) + #expect(probe.callCount == 0) + + let result = await settings.revalidateCodexAccountMenuProjection() - return "\(base64URL(header)).\(base64URL(payload))." + #expect(result == .updated) + #expect(probe.callCount == 1) + #expect(probe.loadedOffMainThread) + #expect( + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email == + "loaded@example.com") } @Test - @MainActor - func `menu display snapshot tolerates stale cache and revalidates off the menu path`() async throws { - let suite = "CodexAccountMenuDisplaySnapshotTests-stale-cache" - let settings = try Self.makeSettings(suite: suite) - let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent( - UUID().uuidString, - isDirectory: true) - try Self.writeCodexAuthFile(homeURL: ambientHome, email: "before@example.com", plan: "pro") - settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path] + func `override snapshot load preserves persisted account menu projection`() { + let settings = self.makeSettings() + let activeSnapshot = self.liveSnapshot(email: "active@example.com") + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: activeSnapshot) + + let otherID = UUID() + let otherAccount = ManagedCodexAccount( + id: otherID, + email: "other@example.com", + managedHomePath: "/tmp/other", + createdAt: 1, + updatedAt: 1, + lastAuthenticatedAt: 1) + let overrideSnapshot = CodexAccountReconciliationSnapshot( + storedAccounts: [otherAccount], + activeStoredAccount: otherAccount, + liveSystemAccount: nil, + matchingStoredAccountForLiveSystemAccount: nil, + activeSource: .managedAccount(id: otherID), + hasUnreadableAddedAccountStore: false) + settings._test_codexAccountSnapshotLoader = { _ in overrideSnapshot } + defer { settings._test_codexAccountSnapshotLoader = nil } + + _ = settings.codexAccountReconciliationSnapshot(activeSourceOverride: .managedAccount(id: otherID)) + + #expect( + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email == + "active@example.com") + } + + @Test + func `managed account change refreshes account menu projection`() { + let settings = self.makeSettings() + let activeSnapshot = self.liveSnapshot(email: "active@example.com") + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: activeSnapshot, loadedAt: Date()) + + let addedAccount = ManagedCodexAccount( + id: UUID(), + email: "added@example.com", + managedHomePath: "/tmp/added", + createdAt: 1, + updatedAt: 1, + lastAuthenticatedAt: 1) + let refreshedSnapshot = CodexAccountReconciliationSnapshot( + storedAccounts: [addedAccount], + activeStoredAccount: nil, + liveSystemAccount: activeSnapshot.liveSystemAccount, + matchingStoredAccountForLiveSystemAccount: nil, + activeSource: .liveSystem, + hasUnreadableAddedAccountStore: false) + settings._test_codexAccountSnapshotLoader = { _ in refreshedSnapshot } + defer { settings._test_codexAccountSnapshotLoader = nil } + + settings.refreshCodexAccountReconciliationAfterManagedAccountsDidChange() + + #expect( + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.contains { + $0.email == "added@example.com" + } == true) + } + + @Test + func `stale menu projection returns immediately then refreshes concurrently`() async { + let settings = self.makeSettings() + let staleSnapshot = self.liveSnapshot(email: "before@example.com") + let probe = CodexAccountSnapshotLoaderProbe(snapshot: self.liveSnapshot(email: "after@example.com")) + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot) + settings._test_codexAccountSnapshotLoader = { _ in probe.load() } SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60 defer { SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil - settings._test_codexReconciliationEnvironment = nil - try? FileManager.default.removeItem(at: ambientHome) + settings._test_codexAccountSnapshotLoader = nil } - let primed = settings.codexAccountReconciliationSnapshot - #expect(primed.liveSystemAccount?.email == "before@example.com") - - // Simulate a cache that has outlived the freshness interval while the auth file changed. - try Self.writeCodexAuthFile(homeURL: ambientHome, email: "after@example.com", plan: "pro") - let cached = try #require(settings.cachedCodexAccountReconciliationSnapshot) - settings.cachedCodexAccountReconciliationSnapshot = CachedCodexAccountReconciliationSnapshot( - activeSource: cached.activeSource, - loadedAt: Date(timeIntervalSinceNow: -3600), - snapshot: cached.snapshot) + #expect( + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email == + "before@example.com") + #expect(probe.callCount == 0) + #expect(settings.codexAccountMenuProjectionNeedsRevalidation) - // The menu path returns the stale cache without a synchronous reload. - let menuSnapshot = settings.codexAccountReconciliationSnapshotForMenuDisplay - #expect(menuSnapshot.liveSystemAccount?.email == "before@example.com") + let result = await settings.revalidateCodexAccountMenuProjection() - // The scheduled revalidation refreshes the cache off the menu path. - let revalidation = try #require(settings.codexAccountSnapshotRevalidationTask) - await revalidation.value - #expect(settings.codexAccountSnapshotRevalidationTask == nil) + #expect(result == .updated) + #expect(probe.callCount == 1) + #expect(probe.loadedOffMainThread) #expect( - settings.codexAccountReconciliationSnapshotForMenuDisplay.liveSystemAccount?.email == + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email == "after@example.com") } @Test - @MainActor - func `menu display snapshot loads synchronously without a cache`() throws { - let suite = "CodexAccountMenuDisplaySnapshotTests-cold-cache" - let settings = try Self.makeSettings(suite: suite) - let ambientHome = FileManager.default.temporaryDirectory.appendingPathComponent( - UUID().uuidString, - isDirectory: true) - try Self.writeCodexAuthFile(homeURL: ambientHome, email: "cold@example.com", plan: "pro") - settings._test_codexReconciliationEnvironment = ["CODEX_HOME": ambientHome.path] + func `revalidation discards result after reconciliation generation changes`() async { + let settings = self.makeSettings() + let staleSnapshot = self.liveSnapshot(email: "before@example.com") + let probe = CodexAccountSnapshotLoaderProbe( + snapshot: self.liveSnapshot(email: "discarded@example.com"), + blocks: true) + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot) + settings._test_codexAccountSnapshotLoader = { _ in probe.load() } SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60 defer { + probe.release() SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil - settings._test_codexReconciliationEnvironment = nil - try? FileManager.default.removeItem(at: ambientHome) + settings._test_codexAccountSnapshotLoader = nil + } + + let task = Task { await settings.revalidateCodexAccountMenuProjection() } + await probe.waitUntilCalled() + settings.invalidateCodexAccountReconciliationSnapshotCache() + probe.release() + + #expect(await task.value == .discarded) + #expect( + settings.codexVisibleAccountProjectionForMenuDisplay?.visibleAccounts.first?.email == + "before@example.com") + } + + @Test + func `fresh menu open coalesces account projection revalidation and identity stays read only`() async throws { + StatusItemController.menuCardRenderingEnabled = false + StatusItemController.setMenuRefreshEnabledForTesting(false) + StatusItemController.setCodexAccountMenuProjectionRevalidationEnabledForTesting(true) + defer { + StatusItemController.resetCodexAccountMenuProjectionRevalidationEnabledForTesting() + StatusItemController.resetMenuRefreshEnabledForTesting() } - #expect(settings.cachedCodexAccountReconciliationSnapshot == nil) - let menuSnapshot = settings.codexAccountReconciliationSnapshotForMenuDisplay - #expect(menuSnapshot.liveSystemAccount?.email == "cold@example.com") - #expect(settings.codexAccountSnapshotRevalidationTask == nil) - #expect(settings.cachedCodexAccountReconciliationSnapshot != nil) + let settings = self.makeSettings() + settings.statusChecksEnabled = false + settings.refreshFrequency = .manual + settings.mergeIcons = false + self.enableOnlyCodex(settings) + let store = UsageStore( + fetcher: UsageFetcher(), + browserDetection: BrowserDetection(cacheTTL: 0), + settings: settings) + let controller = StatusItemController( + store: store, + settings: settings, + account: AccountInfo(email: nil, plan: nil), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: .system) + defer { controller.releaseStatusItemsForTesting() } + + let staleSnapshot = self.liveSnapshot(email: "before@example.com") + let probe = CodexAccountSnapshotLoaderProbe( + snapshot: self.liveSnapshot(email: "after@example.com"), + blocks: true) + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: staleSnapshot) + settings._test_codexAccountSnapshotLoader = { _ in probe.load() } + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = 60 + defer { + probe.release() + SettingsStore.codexAccountReconciliationSnapshotCacheIntervalOverrideForTesting = nil + settings._test_codexAccountSnapshotLoader = nil + } + + let menu = NSMenu() + controller.menuProviders[ObjectIdentifier(menu)] = .codex + controller.markMenuFresh(menu) + #expect(controller.codexAccountMenuDisplay(for: .codex) == nil) + #expect(probe.callCount == 0) + + let versionBeforeOpen = controller.menuContentVersion + controller.menuWillOpen(menu) + let revalidation = try #require(controller.codexAccountMenuProjectionRevalidationTask) + controller.menuWillOpen(menu) + await probe.waitUntilCalled() + + #expect(probe.callCount == 1) + #expect(probe.loadedOffMainThread) + probe.release() + await revalidation.value + + #expect(controller.codexAccountMenuProjectionRevalidationTask == nil) + #expect(controller.menuContentVersion == versionBeforeOpen + 1) + } + + @Test + func `selecting displayed account uses captured source without reconciliation`() throws { + let settings = self.makeSettings() + let firstID = UUID() + let secondID = UUID() + let first = ManagedCodexAccount( + id: firstID, + email: "first@example.com", + managedHomePath: "/tmp/first", + createdAt: 1, + updatedAt: 1, + lastAuthenticatedAt: 1) + let second = ManagedCodexAccount( + id: secondID, + email: "second@example.com", + managedHomePath: "/tmp/second", + createdAt: 1, + updatedAt: 1, + lastAuthenticatedAt: 1) + let snapshot = CodexAccountReconciliationSnapshot( + storedAccounts: [first, second], + activeStoredAccount: first, + liveSystemAccount: nil, + matchingStoredAccountForLiveSystemAccount: nil, + activeSource: .managedAccount(id: firstID), + hasUnreadableAddedAccountStore: false) + let projection = CodexVisibleAccountProjection.make(from: snapshot) + let displayedAccount = try #require(projection.visibleAccounts.first { + $0.selectionSource == .managedAccount(id: secondID) + }) + let probe = CodexAccountSnapshotLoaderProbe(snapshot: snapshot) + settings.cachedCodexAccountMenuProjection = self.cachedProjection(snapshot: snapshot) + settings._test_codexAccountSnapshotLoader = { _ in probe.load() } + defer { settings._test_codexAccountSnapshotLoader = nil } + + settings.selectDisplayedCodexVisibleAccount(displayedAccount) + + #expect(probe.callCount == 0) + #expect(settings.codexActiveSource == .managedAccount(id: secondID)) + #expect(settings.cachedCodexAccountMenuProjection == nil) + } +} + +private final class CodexAccountSnapshotLoaderProbe: @unchecked Sendable { + private let lock = NSLock() + private let snapshot: CodexAccountReconciliationSnapshot + private let blocks: Bool + private let releaseSemaphore = DispatchSemaphore(value: 0) + private var _callCount = 0 + private var _loadedOffMainThread = false + private var released = false + + init(snapshot: CodexAccountReconciliationSnapshot, blocks: Bool = false) { + self.snapshot = snapshot + self.blocks = blocks + } + + var callCount: Int { + self.lock.withLock { self._callCount } + } + + var loadedOffMainThread: Bool { + self.lock.withLock { self._loadedOffMainThread } + } + + func load() -> CodexAccountReconciliationSnapshot { + self.lock.withLock { + self._callCount += 1 + self._loadedOffMainThread = self._loadedOffMainThread || !Thread.isMainThread + } + if self.blocks { + self.releaseSemaphore.wait() + } + return self.snapshot + } + + func waitUntilCalled() async { + while self.callCount == 0 { + await Task.yield() + } + } + + func release() { + let shouldSignal = self.lock.withLock { + guard !self.released else { return false } + self.released = true + return true + } + if shouldSignal { + self.releaseSemaphore.signal() + } } } diff --git a/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift b/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift index 4ad6ce80..c7feea47 100644 --- a/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift +++ b/Tests/CodexBarTests/StatusMenuCodexSwitcherTests.swift @@ -223,6 +223,7 @@ struct StatusMenuCodexSwitcherTests { codexHomePath: "/Users/test/.codex", observedAt: Date()) settings.codexActiveSource = .liveSystem + _ = settings.codexVisibleAccountProjection let fetcher = UsageFetcher() let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings) @@ -285,6 +286,7 @@ struct StatusMenuCodexSwitcherTests { codexHomePath: "/Users/test/.codex", observedAt: Date()) settings.codexActiveSource = .liveSystem + _ = settings.codexVisibleAccountProjection let fetcher = UsageFetcher() let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings) @@ -449,6 +451,7 @@ struct StatusMenuCodexSwitcherTests { codexHomePath: "/Users/test/.codex", observedAt: Date()) settings.codexActiveSource = .liveSystem + _ = settings.codexVisibleAccountProjection let fetcher = UsageFetcher() let store = UsageStore(fetcher: fetcher, browserDetection: BrowserDetection(cacheTTL: 0), settings: settings) From fda0fae9fd6cfd9e2bdef08ec61d3e2f3c7c30fc Mon Sep 17 00:00:00 2001 From: pickaxe <54486432+ProspectOre@users.noreply.github.com> Date: Wed, 10 Jun 2026 13:06:45 -0700 Subject: [PATCH 33/51] Run cost-usage corpus scans off the Swift cooperative thread pool CostUsageScanner and PiSessionCostScanner scans execute synchronously for minutes on large session archives. Running them inline on cooperative-pool task threads starves every other async task in the process: menus freeze while the main thread sits idle, and overlapping provider scans multiply the pressure. Field samples on a 2.5GB corpus showed both provider scans saturating pool threads for 7+ minutes after a cache schema bump while menu opens stalled. All corpus scans and persisted-cache decoding now run on one dedicated serial utility queue (CostUsageScanExecutor), with task cancellation bridged into the scanner-level cancellation checks. Serialization also removes concurrent provider scans racing the same disk. --- CHANGELOG.md | 1 + Sources/CodexBarCore/CostUsageFetcher.swift | 88 +++++++++-------- .../CodexBarCore/CostUsageScanExecutor.swift | 43 +++++++++ .../CostUsageScanExecutorTests.swift | 96 +++++++++++++++++++ 4 files changed, 189 insertions(+), 39 deletions(-) create mode 100644 Sources/CodexBarCore/CostUsageScanExecutor.swift create mode 100644 Tests/CodexBarTests/CostUsageScanExecutorTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index a578f899..641c925a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ ### Fixed - Cost history: keep all per-day model breakdown rows available in a bounded scrolling detail area instead of hiding models after the first four (#1370). Thanks @MoollaMore! +- Cost usage: run local session-corpus scans and cache decoding on a dedicated serial queue instead of the Swift cooperative thread pool, so multi-minute scans of large archives no longer starve the app's async work or freeze menus (#1387, #1392). Thanks @ProspectOre! - Copilot: keep explicitly unlimited chat quotas visible instead of dropping their zero-entitlement payload as unavailable (#1320). Thanks @soumikbhatta! - Security: block credentialed provider redirects that leave the original HTTPS origin while preserving same-origin redirects (#1237). Thanks @Hinotoi-agent! - Codex: keep local token and cost history visible when remote quota data is unavailable (#1390). Thanks @vaibhavarora14! diff --git a/Sources/CodexBarCore/CostUsageFetcher.swift b/Sources/CodexBarCore/CostUsageFetcher.swift index 0dd1a79d..a8019ea1 100644 --- a/Sources/CodexBarCore/CostUsageFetcher.swift +++ b/Sources/CodexBarCore/CostUsageFetcher.swift @@ -146,53 +146,60 @@ public struct CostUsageFetcher: Sendable { if forceRefresh { options.refreshMinIntervalSeconds = 0 } - let checkCancellation: CostUsageScanner.CancellationCheck = { - try Task.checkCancellation() + var resolvedPiOptions = overridePiScannerOptions ?? PiSessionCostScanner.Options() + if resolvedPiOptions.cacheRoot == nil { + resolvedPiOptions.cacheRoot = options.cacheRoot } - try Task.checkCancellation() - var daily = try CostUsageScanner.loadDailyReportCancellable( - provider: provider, - since: since, - until: until, - now: now, - options: options, - checkCancellation: checkCancellation) - try Task.checkCancellation() + if forceRefresh { + resolvedPiOptions.refreshMinIntervalSeconds = 0 + } + let piOptions = resolvedPiOptions - if provider == .vertexai, - !allowVertexClaudeFallback, - options.claudeLogProviderFilter == .vertexAIOnly, - daily.data.isEmpty - { - var fallback = options - fallback.claudeLogProviderFilter = .all - daily = try CostUsageScanner.loadDailyReportCancellable( + try Task.checkCancellation() + // The corpus scans below are synchronous and can run for minutes on large session + // archives. They execute on the dedicated scan queue so they never occupy a cooperative + // pool thread; CostUsageScanExecutor bridges this task's cancellation into the + // scanner-level checks. + let scanOptions = options + let daily = try await CostUsageScanExecutor.run { checkCancellation in + var daily = try CostUsageScanner.loadDailyReportCancellable( provider: provider, since: since, until: until, now: now, - options: fallback, + options: scanOptions, checkCancellation: checkCancellation) - try Task.checkCancellation() - } + try checkCancellation() - if provider == .codex || provider == .claude { - var piOptions = overridePiScannerOptions ?? PiSessionCostScanner.Options() - if piOptions.cacheRoot == nil { - piOptions.cacheRoot = options.cacheRoot + if provider == .vertexai, + !allowVertexClaudeFallback, + scanOptions.claudeLogProviderFilter == .vertexAIOnly, + daily.data.isEmpty + { + var fallback = scanOptions + fallback.claudeLogProviderFilter = .all + daily = try CostUsageScanner.loadDailyReportCancellable( + provider: provider, + since: since, + until: until, + now: now, + options: fallback, + checkCancellation: checkCancellation) + try checkCancellation() } - if forceRefresh { - piOptions.refreshMinIntervalSeconds = 0 + + if provider == .codex || provider == .claude { + let piReport = try PiSessionCostScanner.loadDailyReportCancellable( + provider: provider, + since: since, + until: until, + now: now, + options: piOptions, + checkCancellation: checkCancellation) + try checkCancellation() + daily = CostUsageDailyReport.merged([daily, piReport]) } - let piReport = try PiSessionCostScanner.loadDailyReportCancellable( - provider: provider, - since: since, - until: until, - now: now, - options: piOptions, - checkCancellation: checkCancellation) - try Task.checkCancellation() - daily = CostUsageDailyReport.merged([daily, piReport]) + return daily } return Self.tokenSnapshot(from: daily, now: now, historyDays: clampedHistoryDays) @@ -210,7 +217,9 @@ public struct CostUsageFetcher: Sendable { return nil } - return await Task.detached(priority: .utility) { + // Decoding the persisted scan cache parses multi-megabyte JSON; keep it off the + // cooperative pool alongside the scans themselves. + let cachedSnapshot: CostUsageTokenSnapshot?? = try? await CostUsageScanExecutor.run { _ in let clampedHistoryDays = max(1, min(365, historyDays)) let until = now let since = Calendar.current.date(byAdding: .day, value: -(clampedHistoryDays - 1), to: now) ?? now @@ -247,7 +256,8 @@ public struct CostUsageFetcher: Sendable { from: CostUsageDailyReport.merged(reports), now: now, historyDays: clampedHistoryDays) - }.value + } + return cachedSnapshot.flatMap(\.self) } private static func loadBedrockDailyReport( diff --git a/Sources/CodexBarCore/CostUsageScanExecutor.swift b/Sources/CodexBarCore/CostUsageScanExecutor.swift new file mode 100644 index 00000000..a21c43e5 --- /dev/null +++ b/Sources/CodexBarCore/CostUsageScanExecutor.swift @@ -0,0 +1,43 @@ +import Foundation +import os + +/// Cost-usage scans read and parse the full local session corpus synchronously and can run for +/// minutes on large archives. Executing that work inline on Swift's cooperative thread pool +/// starves every other async task in the process — menus freeze while the main thread sits idle — +/// and overlapping provider scans multiply both the pool pressure and the disk load. This +/// executor pins all corpus scans to a single serial utility queue off the cooperative pool, so +/// long scans cost one dedicated thread instead of the app's async runtime. +public enum CostUsageScanExecutor { + public static let queueLabel = "com.steipete.codexbar.cost-usage-scan" + + private static let queue = DispatchQueue(label: queueLabel, qos: .utility) + + /// Runs `work` on the serial scan queue and bridges Swift task cancellation into the + /// scanner's cooperative `checkCancellation` callbacks. Work that is still queued when the + /// awaiting task is cancelled resumes immediately with `CancellationError` instead of + /// waiting behind an in-flight scan. + public static func run( + _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) + async throws -> T + { + let cancelled = OSAllocatedUnfairLock(initialState: false) + let checkCancellation: @Sendable () throws -> Void = { + if cancelled.withLock({ $0 }) { + throw CancellationError() + } + } + return try await withTaskCancellationHandler { + try await withCheckedThrowingContinuation { continuation in + self.queue.async { + if cancelled.withLock({ $0 }) { + continuation.resume(throwing: CancellationError()) + return + } + continuation.resume(with: Result { try work(checkCancellation) }) + } + } + } onCancel: { + cancelled.withLock { $0 = true } + } + } +} diff --git a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift new file mode 100644 index 00000000..369d92cb --- /dev/null +++ b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift @@ -0,0 +1,96 @@ +import Foundation +import os +import Testing +@testable import CodexBarCore + +struct CostUsageScanExecutorTests { + @Test + func `runs work on the dedicated scan queue and returns its value`() async throws { + let label = try await CostUsageScanExecutor.run { _ in + String(cString: __dispatch_queue_get_label(nil)) + } + #expect(label == CostUsageScanExecutor.queueLabel) + } + + @Test + func `propagates thrown errors`() async { + struct ScanFailure: Error {} + await #expect(throws: ScanFailure.self) { + try await CostUsageScanExecutor.run { _ -> Int in + throw ScanFailure() + } + } + } + + @Test + func `serializes overlapping scans`() async throws { + let state = OSAllocatedUnfairLock(initialState: (active: 0, maxActive: 0)) + try await withThrowingTaskGroup(of: Void.self) { group in + for _ in 0..<4 { + group.addTask { + try await CostUsageScanExecutor.run { _ in + state.withLock { + $0.active += 1 + $0.maxActive = max($0.maxActive, $0.active) + } + usleep(20000) + state.withLock { $0.active -= 1 } + } + } + } + try await group.waitForAll() + } + #expect(state.withLock { $0.maxActive } == 1) + } + + @Test + func `cancellation reaches in-flight work through checkCancellation`() async { + let workStarted = OSAllocatedUnfairLock(initialState: false) + let task = Task { + try await CostUsageScanExecutor.run { checkCancellation in + workStarted.withLock { $0 = true } + while true { + try checkCancellation() + usleep(5000) + } + } + } + while !workStarted.withLock({ $0 }) { + usleep(1000) + } + task.cancel() + await #expect(throws: CancellationError.self) { + try await task.value + } + } + + @Test + func `work cancelled while queued resumes with CancellationError`() async { + let blockerStarted = OSAllocatedUnfairLock(initialState: false) + let releaseBlocker = OSAllocatedUnfairLock(initialState: false) + let blocker = Task { + try await CostUsageScanExecutor.run { _ in + blockerStarted.withLock { $0 = true } + while !releaseBlocker.withLock({ $0 }) { + usleep(2000) + } + } + } + while !blockerStarted.withLock({ $0 }) { + usleep(1000) + } + + let queued = Task { + try await CostUsageScanExecutor.run { _ in + Issue.record("queued work should not run after cancellation") + } + } + queued.cancel() + releaseBlocker.withLock { $0 = true } + + await #expect(throws: CancellationError.self) { + try await queued.value + } + _ = try? await blocker.value + } +} From 01350b23cc6f0c1d67c1621352753a9b61cbf6a4 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 04:45:59 +0100 Subject: [PATCH 34/51] fix: make cost scan cancellation immediate --- .../CodexBarCore/CostUsageScanExecutor.swift | 101 ++++++++++++++++-- .../CostUsageScanExecutorTests.swift | 99 ++++++++++++----- .../CostUsageScanExecutorLinuxTests.swift | 29 +++++ 3 files changed, 194 insertions(+), 35 deletions(-) create mode 100644 TestsLinux/CostUsageScanExecutorLinuxTests.swift diff --git a/Sources/CodexBarCore/CostUsageScanExecutor.swift b/Sources/CodexBarCore/CostUsageScanExecutor.swift index a21c43e5..059240fe 100644 --- a/Sources/CodexBarCore/CostUsageScanExecutor.swift +++ b/Sources/CodexBarCore/CostUsageScanExecutor.swift @@ -1,5 +1,4 @@ import Foundation -import os /// Cost-usage scans read and parse the full local session corpus synchronously and can run for /// minutes on large archives. Executing that work inline on Swift's cooperative thread pool @@ -12,6 +11,90 @@ public enum CostUsageScanExecutor { private static let queue = DispatchQueue(label: queueLabel, qos: .utility) + private final class RunState: @unchecked Sendable { + private enum Phase { + case initial + case queued + case running + case completed + } + + private let lock = NSLock() + private var phase: Phase = .initial + private var cancellationRequested = false + private var continuation: CheckedContinuation? + + func install(_ continuation: CheckedContinuation) -> Bool { + let shouldEnqueue: Bool + let shouldResumeCancellation: Bool + self.lock.lock() + if self.cancellationRequested { + self.phase = .completed + shouldEnqueue = false + shouldResumeCancellation = true + } else { + self.phase = .queued + self.continuation = continuation + shouldEnqueue = true + shouldResumeCancellation = false + } + self.lock.unlock() + + if shouldResumeCancellation { + continuation.resume(throwing: CancellationError()) + } + return shouldEnqueue + } + + func begin() -> Bool { + self.lock.lock() + defer { self.lock.unlock() } + guard self.phase == .queued else { return false } + self.phase = .running + return true + } + + func cancel() { + let continuation: CheckedContinuation? + self.lock.lock() + self.cancellationRequested = true + if self.phase == .queued { + self.phase = .completed + continuation = self.continuation + self.continuation = nil + } else { + continuation = nil + } + self.lock.unlock() + continuation?.resume(throwing: CancellationError()) + } + + func checkCancellation() throws { + self.lock.lock() + let cancellationRequested = self.cancellationRequested + self.lock.unlock() + if cancellationRequested { + throw CancellationError() + } + } + + func complete(with result: Result) { + let continuation: CheckedContinuation? + let resolvedResult: Result + self.lock.lock() + guard self.phase == .running else { + self.lock.unlock() + return + } + self.phase = .completed + continuation = self.continuation + self.continuation = nil + resolvedResult = self.cancellationRequested ? .failure(CancellationError()) : result + self.lock.unlock() + continuation?.resume(with: resolvedResult) + } + } + /// Runs `work` on the serial scan queue and bridges Swift task cancellation into the /// scanner's cooperative `checkCancellation` callbacks. Work that is still queued when the /// awaiting task is cancelled resumes immediately with `CancellationError` instead of @@ -20,24 +103,20 @@ public enum CostUsageScanExecutor { _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) async throws -> T { - let cancelled = OSAllocatedUnfairLock(initialState: false) + let state = RunState() let checkCancellation: @Sendable () throws -> Void = { - if cancelled.withLock({ $0 }) { - throw CancellationError() - } + try state.checkCancellation() } return try await withTaskCancellationHandler { try await withCheckedThrowingContinuation { continuation in + guard state.install(continuation) else { return } self.queue.async { - if cancelled.withLock({ $0 }) { - continuation.resume(throwing: CancellationError()) - return - } - continuation.resume(with: Result { try work(checkCancellation) }) + guard state.begin() else { return } + state.complete(with: Result { try work(checkCancellation) }) } } } onCancel: { - cancelled.withLock { $0 = true } + state.cancel() } } } diff --git a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift index 369d92cb..078de479 100644 --- a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift +++ b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift @@ -1,5 +1,4 @@ import Foundation -import os import Testing @testable import CodexBarCore @@ -24,40 +23,38 @@ struct CostUsageScanExecutorTests { @Test func `serializes overlapping scans`() async throws { - let state = OSAllocatedUnfairLock(initialState: (active: 0, maxActive: 0)) + let state = LockedValue((active: 0, maxActive: 0)) try await withThrowingTaskGroup(of: Void.self) { group in for _ in 0..<4 { group.addTask { try await CostUsageScanExecutor.run { _ in - state.withLock { + state.update { $0.active += 1 $0.maxActive = max($0.maxActive, $0.active) } - usleep(20000) - state.withLock { $0.active -= 1 } + Thread.sleep(forTimeInterval: 0.02) + state.update { $0.active -= 1 } } } } try await group.waitForAll() } - #expect(state.withLock { $0.maxActive } == 1) + #expect(state.read { $0.maxActive } == 1) } @Test func `cancellation reaches in-flight work through checkCancellation`() async { - let workStarted = OSAllocatedUnfairLock(initialState: false) + let workStarted = LockedValue(false) let task = Task { try await CostUsageScanExecutor.run { checkCancellation in - workStarted.withLock { $0 = true } + workStarted.set(true) while true { try checkCancellation() - usleep(5000) + Thread.sleep(forTimeInterval: 0.005) } } } - while !workStarted.withLock({ $0 }) { - usleep(1000) - } + #expect(await self.waitUntil { workStarted.value }) task.cancel() await #expect(throws: CancellationError.self) { try await task.value @@ -66,31 +63,85 @@ struct CostUsageScanExecutorTests { @Test func `work cancelled while queued resumes with CancellationError`() async { - let blockerStarted = OSAllocatedUnfairLock(initialState: false) - let releaseBlocker = OSAllocatedUnfairLock(initialState: false) + let blockerStarted = LockedValue(false) + let releaseBlocker = LockedValue(false) let blocker = Task { try await CostUsageScanExecutor.run { _ in - blockerStarted.withLock { $0 = true } - while !releaseBlocker.withLock({ $0 }) { - usleep(2000) + blockerStarted.set(true) + while !releaseBlocker.value { + Thread.sleep(forTimeInterval: 0.002) } } } - while !blockerStarted.withLock({ $0 }) { - usleep(1000) - } + #expect(await self.waitUntil { blockerStarted.value }) + let queuedWorkStarted = LockedValue(false) let queued = Task { try await CostUsageScanExecutor.run { _ in + queuedWorkStarted.set(true) Issue.record("queued work should not run after cancellation") } } - queued.cancel() - releaseBlocker.withLock { $0 = true } + try? await Task.sleep(for: .milliseconds(50)) - await #expect(throws: CancellationError.self) { - try await queued.value + let cancellationObserved = LockedValue(nil) + let observer = Task { + do { + try await queued.value + cancellationObserved.set(false) + } catch is CancellationError { + cancellationObserved.set(true) + } catch { + cancellationObserved.set(false) + } } + queued.cancel() + + #expect(await self.waitUntil { cancellationObserved.value != nil }) + #expect(cancellationObserved.value == true) + #expect(!queuedWorkStarted.value) + #expect(!releaseBlocker.value) + + releaseBlocker.set(true) + await observer.value _ = try? await blocker.value } + + private func waitUntil( + timeout: Duration = .seconds(1), + condition: @escaping @Sendable () -> Bool) async -> Bool + { + let clock = ContinuousClock() + let deadline = clock.now.advanced(by: timeout) + while clock.now < deadline { + if condition() { return true } + try? await Task.sleep(for: .milliseconds(5)) + } + return condition() + } +} + +private final class LockedValue: @unchecked Sendable { + private let lock = NSLock() + private var storage: Value + + init(_ value: Value) { + self.storage = value + } + + var value: Value { + self.lock.withLock { self.storage } + } + + func read(_ body: (Value) -> Result) -> Result { + self.lock.withLock { body(self.storage) } + } + + func set(_ value: Value) { + self.lock.withLock { self.storage = value } + } + + func update(_ body: (inout Value) -> Void) { + self.lock.withLock { body(&self.storage) } + } } diff --git a/TestsLinux/CostUsageScanExecutorLinuxTests.swift b/TestsLinux/CostUsageScanExecutorLinuxTests.swift new file mode 100644 index 00000000..e286e535 --- /dev/null +++ b/TestsLinux/CostUsageScanExecutorLinuxTests.swift @@ -0,0 +1,29 @@ +import CodexBarCore +import Foundation +import Testing + +@Suite +struct CostUsageScanExecutorLinuxTests { + @Test + func returnsWorkValue() async throws { + let value = try await CostUsageScanExecutor.run { _ in 42 } + #expect(value == 42) + } + + @Test + func cancelledTaskThrowsCancellationError() async { + let task = Task { + try await CostUsageScanExecutor.run { checkCancellation in + while true { + try checkCancellation() + Thread.sleep(forTimeInterval: 0.005) + } + } + } + task.cancel() + + await #expect(throws: CancellationError.self) { + try await task.value + } + } +} From e7aa65290b6950ce4f4bf5888d96dae768fe1b8f Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 04:53:02 +0100 Subject: [PATCH 35/51] test: isolate cost scan executor queues --- .../CodexBarCore/CostUsageScanExecutor.swift | 10 +++++++- .../CostUsageScanExecutorTests.swift | 23 +++++++++++++------ 2 files changed, 25 insertions(+), 8 deletions(-) diff --git a/Sources/CodexBarCore/CostUsageScanExecutor.swift b/Sources/CodexBarCore/CostUsageScanExecutor.swift index 059240fe..aef8b2b7 100644 --- a/Sources/CodexBarCore/CostUsageScanExecutor.swift +++ b/Sources/CodexBarCore/CostUsageScanExecutor.swift @@ -102,6 +102,14 @@ public enum CostUsageScanExecutor { public static func run( _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) async throws -> T + { + try await self.run(on: self.queue, work) + } + + static func run( + on queue: DispatchQueue, + _ work: @escaping @Sendable (_ checkCancellation: @escaping @Sendable () throws -> Void) throws -> T) + async throws -> T { let state = RunState() let checkCancellation: @Sendable () throws -> Void = { @@ -110,7 +118,7 @@ public enum CostUsageScanExecutor { return try await withTaskCancellationHandler { try await withCheckedThrowingContinuation { continuation in guard state.install(continuation) else { return } - self.queue.async { + queue.async { guard state.begin() else { return } state.complete(with: Result { try work(checkCancellation) }) } diff --git a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift index 078de479..8ea5a03b 100644 --- a/Tests/CodexBarTests/CostUsageScanExecutorTests.swift +++ b/Tests/CodexBarTests/CostUsageScanExecutorTests.swift @@ -5,17 +5,19 @@ import Testing struct CostUsageScanExecutorTests { @Test func `runs work on the dedicated scan queue and returns its value`() async throws { - let label = try await CostUsageScanExecutor.run { _ in + let queue = self.makeQueue() + let label = try await CostUsageScanExecutor.run(on: queue) { _ in String(cString: __dispatch_queue_get_label(nil)) } - #expect(label == CostUsageScanExecutor.queueLabel) + #expect(label == queue.label) } @Test func `propagates thrown errors`() async { struct ScanFailure: Error {} + let queue = self.makeQueue() await #expect(throws: ScanFailure.self) { - try await CostUsageScanExecutor.run { _ -> Int in + try await CostUsageScanExecutor.run(on: queue) { _ -> Int in throw ScanFailure() } } @@ -23,11 +25,12 @@ struct CostUsageScanExecutorTests { @Test func `serializes overlapping scans`() async throws { + let queue = self.makeQueue() let state = LockedValue((active: 0, maxActive: 0)) try await withThrowingTaskGroup(of: Void.self) { group in for _ in 0..<4 { group.addTask { - try await CostUsageScanExecutor.run { _ in + try await CostUsageScanExecutor.run(on: queue) { _ in state.update { $0.active += 1 $0.maxActive = max($0.maxActive, $0.active) @@ -44,9 +47,10 @@ struct CostUsageScanExecutorTests { @Test func `cancellation reaches in-flight work through checkCancellation`() async { + let queue = self.makeQueue() let workStarted = LockedValue(false) let task = Task { - try await CostUsageScanExecutor.run { checkCancellation in + try await CostUsageScanExecutor.run(on: queue) { checkCancellation in workStarted.set(true) while true { try checkCancellation() @@ -63,10 +67,11 @@ struct CostUsageScanExecutorTests { @Test func `work cancelled while queued resumes with CancellationError`() async { + let queue = self.makeQueue() let blockerStarted = LockedValue(false) let releaseBlocker = LockedValue(false) let blocker = Task { - try await CostUsageScanExecutor.run { _ in + try await CostUsageScanExecutor.run(on: queue) { _ in blockerStarted.set(true) while !releaseBlocker.value { Thread.sleep(forTimeInterval: 0.002) @@ -77,7 +82,7 @@ struct CostUsageScanExecutorTests { let queuedWorkStarted = LockedValue(false) let queued = Task { - try await CostUsageScanExecutor.run { _ in + try await CostUsageScanExecutor.run(on: queue) { _ in queuedWorkStarted.set(true) Issue.record("queued work should not run after cancellation") } @@ -107,6 +112,10 @@ struct CostUsageScanExecutorTests { _ = try? await blocker.value } + private func makeQueue() -> DispatchQueue { + DispatchQueue(label: "\(CostUsageScanExecutor.queueLabel).tests.\(UUID().uuidString)") + } + private func waitUntil( timeout: Duration = .seconds(1), condition: @escaping @Sendable () -> Bool) async -> Bool From 9d7967ea8a0f5dccb0cd6776f071517ec4d5f076 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 05:10:55 +0100 Subject: [PATCH 36/51] fix: keep Cost menu row width stable --- CHANGELOG.md | 1 + .../StatusItemController+CostMenuCard.swift | 62 +++++++++++++- .../CodexBar/StatusItemController+Menu.swift | 5 +- .../StatusMenuCostMenuCardTests.swift | 84 +++++++++++++++++++ .../StatusMenuHostedSubmenuRefreshTests.swift | 6 +- 5 files changed, 153 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 641c925a..56633ee4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - Localization: add Japanese as a selectable app language (#1385). Thanks @naoterumaker! ### Fixed +- Menu bar: keep large dynamic Cost totals inside the fixed-width hosted row so switching providers no longer widens the menu or misaligns submenu arrows. - Cost history: keep all per-day model breakdown rows available in a bounded scrolling detail area instead of hiding models after the first four (#1370). Thanks @MoollaMore! - Cost usage: run local session-corpus scans and cache decoding on a dedicated serial queue instead of the Swift cooperative thread pool, so multi-minute scans of large archives no longer starve the app's async work or freeze menus (#1387, #1392). Thanks @ProspectOre! - Copilot: keep explicitly unlimited chat quotas visible instead of dropping their zero-entitlement payload as unavailable (#1320). Thanks @soumikbhatta! diff --git a/Sources/CodexBar/StatusItemController+CostMenuCard.swift b/Sources/CodexBar/StatusItemController+CostMenuCard.swift index a0bf4793..c84f296f 100644 --- a/Sources/CodexBar/StatusItemController+CostMenuCard.swift +++ b/Sources/CodexBar/StatusItemController+CostMenuCard.swift @@ -1,13 +1,73 @@ import AppKit +import SwiftUI + +private struct CostMenuCardRowView: View { + let title: String + let detailLines: [String] + let width: CGFloat + @Environment(\.menuItemHighlighted) private var isHighlighted + + var body: some View { + VStack(alignment: .leading, spacing: 2) { + Text(self.title) + .font(.system(size: NSFont.menuFont(ofSize: 0).pointSize)) + .lineLimit(1) + ForEach(self.detailLines.indices, id: \.self) { index in + Text(self.detailLines[index]) + .font(.system(size: NSFont.smallSystemFontSize)) + .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted)) + .lineLimit(1) + .truncationMode(.tail) + } + } + .padding(.leading, 14) + .padding(.trailing, 28) + .padding(.vertical, 6) + .frame(width: self.width, alignment: .leading) + } +} extension StatusItemController { static var costMenuTitle: String { L("Cost") } - func makeCostMenuCardItem(model: UsageMenuCardView.Model, submenu: NSMenu?) -> NSMenuItem { + func makeCostMenuCardItem( + model: UsageMenuCardView.Model, + submenu: NSMenu?, + width: CGFloat) -> NSMenuItem + { let tooltipLines = Self.costMenuTooltipLines(tokenUsage: model.tokenUsage) let visibleDetailLines = Self.costMenuVisibleDetailLines(tokenUsage: model.tokenUsage) + guard Self.menuCardRenderingEnabled else { + return Self.makeNativeCostMenuCardItem( + visibleDetailLines: visibleDetailLines, + tooltipLines: tooltipLines, + submenu: submenu) + } + + let item = self.makeMenuCardItem( + CostMenuCardRowView( + title: Self.costMenuTitle, + detailLines: visibleDetailLines, + width: width), + id: "menuCardCost", + width: width, + heightCacheScope: model.provider.rawValue, + heightCacheFingerprint: "costMenuRow:\(visibleDetailLines.count)", + submenu: submenu, + submenuIndicatorAlignment: .trailing, + submenuIndicatorTopPadding: 0) + item.title = Self.costMenuTitle + item.toolTip = tooltipLines.joined(separator: "\n") + return item + } + + private static func makeNativeCostMenuCardItem( + visibleDetailLines: [String], + tooltipLines: [String], + submenu: NSMenu?) -> NSMenuItem + { let item = NSMenuItem(title: Self.costMenuTitle, action: nil, keyEquivalent: "") item.isEnabled = true item.representedObject = "menuCardCost" diff --git a/Sources/CodexBar/StatusItemController+Menu.swift b/Sources/CodexBar/StatusItemController+Menu.swift index d1a491b7..dbc61ab6 100644 --- a/Sources/CodexBar/StatusItemController+Menu.swift +++ b/Sources/CodexBar/StatusItemController+Menu.swift @@ -1326,7 +1326,10 @@ extension StatusItemController { } let costSubmenu = webItems.hasCostHistory ? self .makeCostHistorySubmenu(provider: provider, width: width) : nil - menu.addItem(self.makeCostMenuCardItem(model: model, submenu: costSubmenu)) + menu.addItem(self.makeCostMenuCardItem( + model: model, + submenu: costSubmenu, + width: width)) } } diff --git a/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift b/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift index b1f73389..b09889fc 100644 --- a/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift +++ b/Tests/CodexBarTests/StatusMenuCostMenuCardTests.swift @@ -1,3 +1,6 @@ +import AppKit +import CodexBarCore +import SwiftUI import Testing @testable import CodexBar @@ -43,4 +46,85 @@ struct StatusMenuCostMenuCardTests { "Cost refresh failed.", ]) } + + @Test + func `rendered cost menu keeps long dynamic details inside fixed row width`() throws { + let previousRendering = StatusItemController.menuCardRenderingEnabled + StatusItemController.menuCardRenderingEnabled = true + defer { StatusItemController.menuCardRenderingEnabled = previousRendering } + + let settings = self.makeSettings() + let fetcher = UsageFetcher() + let store = UsageStore( + fetcher: fetcher, + browserDetection: BrowserDetection(cacheTTL: 0), + settings: settings) + let controller = StatusItemController( + store: store, + settings: settings, + account: fetcher.loadAccountInfo(), + updater: DisabledUpdaterController(), + preferencesSelection: PreferencesSelection(), + statusBar: .system) + defer { controller.releaseStatusItemsForTesting() } + + let width = StatusItemController.menuCardBaseWidth + let tokenUsage = UsageMenuCardView.Model.TokenUsageSection( + sessionLine: "Today: $227.42 - 267M tokens - " + String(repeating: "wide ", count: 20), + monthLine: "Last 30 days: $52,431.09 - 77B tokens - " + String(repeating: "wide ", count: 20), + hintLine: "Costs are estimated from local usage.", + errorLine: nil, + errorCopyText: nil) + let model = self.makeModel(tokenUsage: tokenUsage) + let submenu = NSMenu() + + let item = controller.makeCostMenuCardItem( + model: model, + submenu: submenu, + width: width) + let view = try #require(item.view) + + #expect(view is any MenuCardMeasuring) + #expect(abs(view.frame.width - width) <= 0.5) + #expect(item.title == "Cost") + #expect(item.toolTip?.contains("$52,431.09") == true) + #expect(item.submenu === submenu) + #expect(item.target === controller) + #expect(item.action.map(NSStringFromSelector) == "menuCardNoOp:") + } + + private func makeSettings() -> SettingsStore { + let suite = "StatusMenuCostMenuCardTests-\(UUID().uuidString)" + let defaults = UserDefaults(suiteName: suite)! + defaults.removePersistentDomain(forName: suite) + return SettingsStore( + userDefaults: defaults, + configStore: testConfigStore(suiteName: suite), + zaiTokenStore: NoopZaiTokenStore(), + syntheticTokenStore: NoopSyntheticTokenStore()) + } + + private func makeModel( + tokenUsage: UsageMenuCardView.Model.TokenUsageSection) -> UsageMenuCardView.Model + { + UsageMenuCardView.Model( + provider: .codex, + providerName: "Codex", + email: "user@example.com", + subtitleText: "Updated now", + subtitleStyle: .info, + planText: "Pro", + metrics: [], + usageNotes: [], + openAIAPIUsage: nil, + inlineUsageDashboard: nil, + creditsText: nil, + creditsRemaining: nil, + creditsHintText: nil, + creditsHintCopyText: nil, + providerCost: nil, + tokenUsage: tokenUsage, + placeholder: nil, + progressColor: .blue) + } } diff --git a/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift b/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift index 86ad13c1..b509d998 100644 --- a/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift +++ b/Tests/CodexBarTests/StatusMenuHostedSubmenuRefreshTests.swift @@ -43,11 +43,11 @@ struct StatusMenuHostedSubmenuRefreshTests { controller.menuVersions[parentKey] = controller.menuContentVersion let costItem = try #require(menu.items.first { ($0.representedObject as? String) == "menuCardCost" }) - #expect(costItem.view == nil) + #expect(costItem.view is any MenuCardMeasuring) let submenu = try #require(costItem.submenu) let submenuAction = try #require(costItem.action) - #expect(NSStringFromSelector(submenuAction) == "submenuAction:") - #expect((costItem.target as? NSMenu) === submenu) + #expect(NSStringFromSelector(submenuAction) == "menuCardNoOp:") + #expect(costItem.target === controller) #expect(submenu.items.first?.representedObject as? String == StatusItemController.costHistoryChartID) #expect(submenu.minimumWidth >= StatusItemController.menuCardBaseWidth) #expect(submenu.items.first?.view == nil) From b4b1edcc17a3eeaf1930e08119455baca0f1468a Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 06:03:00 +0100 Subject: [PATCH 37/51] chore: prepare 0.33.0 release --- CHANGELOG.md | 2 +- version.env | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 56633ee4..4eef0d09 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.32.6 — Unreleased +## 0.33.0 — 2026-06-11 ### Added - Settings: choose Terminal.app or iTerm for Open Terminal actions, including Vertex AI login commands (#1225, fixes #1147). Thanks @Yuxin-Qiao! diff --git a/version.env b/version.env index 977410df..59084b97 100644 --- a/version.env +++ b/version.env @@ -1,2 +1,2 @@ -MARKETING_VERSION=0.32.6 +MARKETING_VERSION=0.33.0 BUILD_NUMBER=81 From 6d156e70c712d3a9942ff1f5d7b246fa4d045073 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 06:06:37 +0100 Subject: [PATCH 38/51] style: apply SwiftFormat to utilization history tests --- .../CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift | 1 - 1 file changed, 1 deletion(-) diff --git a/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift b/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift index 3d41598d..8ee80c99 100644 --- a/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift +++ b/Tests/CodexBarTests/PlanUtilizationHistoryChartMenuViewTests.swift @@ -2,7 +2,6 @@ import Foundation import Testing @testable import CodexBar -@Suite struct PlanUtilizationHistoryChartMenuViewTests { @Test func `merged entries preserve first occurrence order while removing duplicates`() { From 6cf422512061924c5bae185fef5dd39194e0ac50 Mon Sep 17 00:00:00 2001 From: Peter Steinberger Date: Thu, 11 Jun 2026 06:35:12 +0100 Subject: [PATCH 39/51] docs: update appcast for 0.33.0 --- appcast.xml | 64 ++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 44 insertions(+), 20 deletions(-) diff --git a/appcast.xml b/appcast.xml index af60a21d..c4825ded 100644 --- a/appcast.xml +++ b/appcast.xml @@ -2,6 +2,50 @@ CodexBar + + 0.33.0 + Thu, 11 Jun 2026 06:35:11 +0100 + https://raw.githubusercontent.com/steipete/CodexBar/main/appcast.xml + 81 + 0.33.0 + 14.0 + CodexBar 0.33.0 +

Added

Settings: choose Terminal.app or iTerm for Open Terminal actions, including Vertex AI login commands (#1225, fixes #1147). Thanks @Yuxin-Qiao!
Localization: add Japanese as a selectable app language (#1385). Thanks @naoterumaker!

Fixed

Menu bar: keep large dynamic Cost totals inside the fixed-width hosted row so switching providers no longer widens the menu or misaligns submenu arrows.
Cost history: keep all per-day model breakdown rows available in a bounded scrolling detail area instead of hiding models after the first four (#1370). Thanks @MoollaMore!
Cost usage: run local session-corpus scans and cache decoding on a dedicated serial queue instead of the Swift cooperative thread pool, so multi-minute scans of large archives no longer starve the app's async work or freeze menus (#1387, #1392). Thanks @ProspectOre!
Copilot: keep explicitly unlimited chat quotas visible instead of dropping their zero-entitlement payload as unavailable (#1320). Thanks @soumikbhatta!
Security: block credentialed provider redirects that leave the original HTTPS origin while preserving same-origin redirects (#1237). Thanks @Hinotoi-agent!
Codex: keep local token and cost history visible when remote quota data is unavailable (#1390). Thanks @vaibhavarora14!
Doubao: confirm zero-remaining HTTP 200 request limits before falling back, preserving genuine exhaustion and avoiding false 100% usage (#1383). Thanks @LeoLin990405 and @foobra!
Menu bar: defer pasteboard writes and copy feedback outside the NSMenu tracking callback so in-menu copy buttons no longer beachball on macOS 26 (#1388). Thanks @LeoLin990405!
Menu bar: defer merged status-icon redraws until the tracked menu closes while preserving animation lifecycle and quota-warning timing, reducing WindowServer churn during long menu sessions (#1409, fixes #1399). Thanks @kiranmagic7!
Provider status: decode status feeds on the concurrent executor and reuse ISO8601 formatters, removing a measured main-thread stall during refreshes (#1406). Thanks @ProspectOre!
Menu bar: keep one stable width across merged provider tabs and resize every hosted card row to AppKit's final menu width so provider switching no longer leaves a widened menu with inset submenu arrows (#1410).
Menu bar: keep Codex auth.json reads, JWT parsing, and fingerprint hashing off the menu-build path by rendering a cached account snapshot and revalidating it asynchronously (#1401). Thanks @ProspectOre!
Menu bar: defer Overview-row provider transitions out of AppKit's click callback so opening provider detail no longer performs a full synchronous menu rebuild (#1325).
Menu bar: open cached menus immediately after data-only invalidations, then refresh missing or stale provider data asynchronously without queuing redundant work on close (#1398). Thanks @joshuavial!
Menu bar: recycle SwiftUI card hosting views across data refreshes and provider switches, and reconcile matching menu rows in place instead of removing and reinserting every row, cutting open-click, switch, and idle rebuild cost (#1394). Thanks @bcssewl!
Menu bar: gate the provider-switcher shortcut monitor's event-queue peek behind session event counters so hover-driven menu tracking no longer calls NSApp.nextEvent on every run-loop pass (#1397). Thanks @bcssewl!
Development: disable Keychain access for unbundled executables to avoid repeated password prompts while preserving packaged app behavior (#1271). Thanks @Yuxin-Qiao!
Antigravity: exclude model quotas without a remaining fraction from family summaries so they no longer mask tracked usage in the automatic menu-bar metric (#1369). Thanks @Martin-Hausleitner!
Claude: add bundled Fable 5 pricing, account for native 1-hour cache-write usage, and refresh Sonnet 4.6 full-context rates (#1368). Thanks @MoollaMore!
Claude: show a direct claude.ai re-login action when a configured web session expires or becomes invalid (#1377). Thanks @LeoLin990405!
Menu: reuse unchanged hosted chart submenus and precompute utilization history models to reduce expand and hover stalls (#1379). Thanks @hhh2210!
Menu bar: defer data-refresh rebuilds until the tracked menu closes, avoiding multi-second WindowServer stalls with slower providers such as Grok (#1376). Thanks @jangisaac-dev!
OpenAI Web: evict cached dashboard WebViews after their idle timeout even when no later cache activity occurs, releasing hidden WebKit helper processes (#1386). Thanks @naoterumaker!
Xiaomi MiMo: import automatic session cookies from Safari, Chrome variants, Firefox, and Edge instead of limiting discovery to Chrome (#1304). Thanks @Yuxin-Qiao!

View full changelog

+]]>

0.32.5

Tue, 09 Jun 2026 08:30:33 +0100

0.32.3

Tue, 02 Jun 2026 12:30:56 +0100

CodexBar 0.32.3

Fixed

Menu bar: stop forcing a private preferred-position value for fresh status items; suspicious stored positions are now cleared so AppKit can place CodexBar normally on macOS 26 / 5K displays (#1267). Thanks @AdrianSimionov, @kirocop, and @Yuxin-Qiao!
Menu bar: cache provider brand icons so merged-icon status updates no longer repeatedly parse SVG assets on the main thread during hover/open animations (#1235, #1274). Thanks @andradebruno, @xingpz2008, and @Yuxin-Qiao!
Copilot: treat GitHub Copilot Business token-billing zero-entitlement quotas as unavailable instead of showing misleading 0% used usage (#1258, #1270). Thanks @devYRPauli!
Menu bar: prepare closed menus after refresh and only reuse stale dropdown content for data-refresh invalidations so merged menu opens stay responsive without bypassing privacy or structure changes (#1261). Thanks @ProspectOre!
OpenAI Web: stop reloading away from login and Cloudflare blocking states so the dashboard WebView does not loop on route corrections (#1259). Thanks @ProspectOre!

View full changelog