wehub-resource-sync
362 lines
16 KiB
Swift
362 lines
16 KiB
Swift
import AppKit
|
|
import CodexBarCore
|
|
import QuartzCore
|
|
|
|
extension StatusItemController {
|
|
private static let providerSwitcherMenuRebuildDebounceNanoseconds: UInt64 = 0
|
|
|
|
private struct ScheduledOpenMenuRebuild {
|
|
let provider: UsageProvider?
|
|
let shouldCloseHostedSubviewMenus: Bool
|
|
let beforeRebuild: (@MainActor () -> Bool)?
|
|
}
|
|
|
|
func didMenuAdjunctReadinessChange() -> Bool {
|
|
let signature = self.menuAdjunctReadinessSignature()
|
|
defer { self.recordMenuAdjunctReadinessBaseline(signature) }
|
|
return signature != self.lastMenuAdjunctReadinessSignature
|
|
}
|
|
|
|
/// Resyncs the readiness baseline to the data the menu was just built from.
|
|
///
|
|
/// Because the baseline is no longer recomputed on every store change while all menus are closed,
|
|
/// it can drift from the live store state. When a root menu opens and is actually rebuilt (or is
|
|
/// already fresh for the current `menuContentVersion`), the baseline must be re-anchored here;
|
|
/// otherwise a later open-menu store change that happens to revert to the stale baseline value would
|
|
/// be treated as "unchanged" and skip a needed rebuild, leaving the visible menu showing the older
|
|
/// content. Callers must **not** invoke this when `refreshMenuForOpenIfNeeded` preserved stale
|
|
/// content during an in-flight refresh — that would record live store data while the visible menu
|
|
/// still shows older content and mask the refresh-completion update.
|
|
func resyncMenuAdjunctReadinessBaseline() {
|
|
self.recordMenuAdjunctReadinessBaseline(self.menuAdjunctReadinessSignature())
|
|
}
|
|
|
|
/// Resyncs a root-menu baseline after open and handles the narrow race where a store change
|
|
/// has updated live data but its deferred observation task has not invalidated menus yet.
|
|
///
|
|
/// If a previously fresh menu sees new live data before the observer version tick, invalidate all
|
|
/// menus first and rebuild only the opened menu. The matching observer can then skip the expensive
|
|
/// readiness comparison while still invalidating menu-observed state that is not in the signature.
|
|
func resyncMenuAdjunctReadinessBaselineForRootOpen(
|
|
_ menu: NSMenu,
|
|
provider: UsageProvider?,
|
|
menuWasFreshBeforeOpen: Bool)
|
|
{
|
|
let signature = self.menuAdjunctReadinessSignature()
|
|
let menuKey = ObjectIdentifier(menu)
|
|
let menuRenderedCurrentSignature =
|
|
self.menuSession.renderedVersion(for: menuKey) == self.menuSession.contentVersion &&
|
|
self.menuReadinessSignatures[menuKey] == signature
|
|
guard signature != self.lastMenuAdjunctReadinessSignature else {
|
|
guard menuWasFreshBeforeOpen, !menuRenderedCurrentSignature else {
|
|
self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
|
|
return
|
|
}
|
|
guard !self.isMenuDataRefreshInFlight else { return }
|
|
self.invalidateMenus()
|
|
self.populateMenu(menu, provider: provider)
|
|
self.markMenuFresh(menu)
|
|
self.rememberRootOpenHandledMenuObservation(signature: signature)
|
|
self.recordMenuAdjunctReadinessBaseline(signature)
|
|
return
|
|
}
|
|
|
|
if menuWasFreshBeforeOpen {
|
|
if self.isMenuDataRefreshInFlight, !menuRenderedCurrentSignature {
|
|
return
|
|
}
|
|
if menuRenderedCurrentSignature {
|
|
self.recordMenuAdjunctReadinessBaseline(signature)
|
|
return
|
|
}
|
|
self.invalidateMenus()
|
|
self.populateMenu(menu, provider: provider)
|
|
self.markMenuFresh(menu)
|
|
self.rememberRootOpenHandledMenuObservation(signature: signature)
|
|
}
|
|
self.recordMenuAdjunctReadinessBaseline(signature)
|
|
}
|
|
|
|
private func recordMenuAdjunctReadinessBaseline(_ signature: String) {
|
|
self.lastMenuAdjunctReadinessSignature = signature
|
|
self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
|
|
}
|
|
|
|
private func rememberRootOpenHandledMenuObservation(signature: String) {
|
|
self.rootOpenHandledMenuObservationSignature = signature
|
|
Task { @MainActor [weak self] in
|
|
await Task.yield()
|
|
if self?.rootOpenHandledMenuObservationSignature == signature {
|
|
self?.rootOpenHandledMenuObservationSignature = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func consumeRootOpenHandledMenuObservationIfNeeded() -> Bool {
|
|
guard let handledSignature = self.rootOpenHandledMenuObservationSignature else { return false }
|
|
let signature = self.menuAdjunctReadinessSignature()
|
|
guard signature == handledSignature else {
|
|
self.rootOpenHandledMenuObservationSignature = nil
|
|
return false
|
|
}
|
|
self.rootOpenHandledMenuObservationSignature = nil
|
|
self.recordMenuAdjunctReadinessBaseline(signature)
|
|
return true
|
|
}
|
|
|
|
func menuAdjunctReadinessSignature() -> String {
|
|
let dashboard = self.store.openAIDashboard
|
|
let dashboardUsageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
|
|
from: dashboard?.usageBreakdown ?? [])
|
|
var parts = [
|
|
"costEnabled=\(self.settings.costUsageEnabled ? "1" : "0")",
|
|
"costStyle=\(self.settings.costSummaryDisplayStyle.rawValue)",
|
|
"openAIAttached=\(self.store.openAIDashboardAttachmentAuthorized ? "1" : "0")",
|
|
"openAILogin=\(self.store.openAIDashboardRequiresLogin ? "1" : "0")",
|
|
"openAIUpdated=\(Self.millisecondsSinceEpoch(dashboard?.updatedAt))",
|
|
"openAIDaily=\(Self.dashboardBreakdownReadinessSignature(dashboard?.dailyBreakdown ?? []))",
|
|
"openAIUsage=\(Self.dashboardBreakdownReadinessSignature(dashboardUsageBreakdown))",
|
|
"credits=\(self.store.credits == nil ? "0" : "1")",
|
|
"planHistoryRevision=\(self.store.planUtilizationHistoryRevision)",
|
|
"claudeSwapRevision=\(self.store.claudeSwapRevision)",
|
|
]
|
|
|
|
for provider in self.store.enabledProvidersForDisplay() {
|
|
let tokenSignature = self.tokenSnapshotReadinessSignature(for: provider)
|
|
let usageHistoryVisible = self.store.supportsPlanUtilizationHistory(for: provider) &&
|
|
!self.store.shouldHidePlanUtilizationMenuItem(for: provider)
|
|
parts.append(
|
|
[
|
|
provider.rawValue,
|
|
"token=\(tokenSignature)",
|
|
"statusComponents=\(self.statusComponentsRenderSignature(for: provider))",
|
|
"refreshing=\(self.store.shouldShowRefreshingMenuCardIndicator(for: provider) ? "1" : "0")",
|
|
"usageHistory=\(usageHistoryVisible ? "1" : "0")",
|
|
].joined(separator: ":"))
|
|
}
|
|
|
|
return parts.joined(separator: "|")
|
|
}
|
|
|
|
static func dashboardBreakdownReadinessSignature(
|
|
_ breakdown: [OpenAIDashboardDailyBreakdown]) -> String
|
|
{
|
|
breakdown
|
|
.map { day in
|
|
let services = day.services
|
|
.map { "\($0.service)=\(Self.formatDoubleForSignature($0.creditsUsed))" }
|
|
.joined(separator: ",")
|
|
return [
|
|
day.day,
|
|
Self.formatDoubleForSignature(day.totalCreditsUsed),
|
|
services,
|
|
].joined(separator: ":")
|
|
}
|
|
.joined(separator: ";")
|
|
}
|
|
|
|
private func tokenSnapshotReadinessSignature(for provider: UsageProvider) -> String {
|
|
guard let snapshot = self.store.tokenSnapshot(for: provider) else { return "none" }
|
|
let daily = snapshot.daily
|
|
.map { entry in
|
|
[
|
|
entry.date,
|
|
"\(entry.totalTokens ?? -1)",
|
|
Self.formatOptionalDoubleForSignature(entry.costUSD),
|
|
].joined(separator: ",")
|
|
}
|
|
.joined(separator: ";")
|
|
let projects = snapshot.projects
|
|
.map { project in
|
|
let sources = project.sources
|
|
.map { source in
|
|
[
|
|
source.name,
|
|
source.path ?? "",
|
|
"\(source.totalTokens ?? -1)",
|
|
Self.formatOptionalDoubleForSignature(source.totalCostUSD),
|
|
].joined(separator: ",")
|
|
}
|
|
.joined(separator: "|")
|
|
return [
|
|
project.name,
|
|
project.path ?? "",
|
|
"\(project.totalTokens ?? -1)",
|
|
Self.formatOptionalDoubleForSignature(project.totalCostUSD),
|
|
sources,
|
|
].joined(separator: ",")
|
|
}
|
|
.joined(separator: ";")
|
|
return [
|
|
"sessionTokens=\(snapshot.sessionTokens ?? -1)",
|
|
"sessionCost=\(Self.formatOptionalDoubleForSignature(snapshot.sessionCostUSD))",
|
|
"lastTokens=\(snapshot.last30DaysTokens ?? -1)",
|
|
"lastCost=\(Self.formatOptionalDoubleForSignature(snapshot.last30DaysCostUSD))",
|
|
"updated=\(Int(snapshot.updatedAt.timeIntervalSince1970 * 1000))",
|
|
"daily=\(daily)",
|
|
"projects=\(projects)",
|
|
].joined(separator: ",")
|
|
}
|
|
|
|
private static func millisecondsSinceEpoch(_ date: Date?) -> Int {
|
|
guard let date else { return -1 }
|
|
return Int(date.timeIntervalSince1970 * 1000)
|
|
}
|
|
|
|
private static func formatOptionalDoubleForSignature(_ value: Double?) -> String {
|
|
guard let value else { return "nil" }
|
|
return self.formatDoubleForSignature(value)
|
|
}
|
|
|
|
/// The signature is only ever compared for equality against the previous signature, so it does
|
|
/// not need a human-readable decimal form. `String(format: "%.8f", …)` is a surprisingly hot
|
|
/// cost here because it runs for every daily/service value across every enabled provider on each
|
|
/// store mutation. The raw bit pattern is both exact (no rounding collisions) and far cheaper.
|
|
private static func formatDoubleForSignature(_ value: Double) -> String {
|
|
String(value.bitPattern, radix: 16)
|
|
}
|
|
|
|
func performMenuMutationWithoutAnimation(_ updates: () -> Void) {
|
|
CATransaction.begin()
|
|
CATransaction.setDisableActions(true)
|
|
defer { CATransaction.commit() }
|
|
updates()
|
|
}
|
|
|
|
func deferSwitcherMenuRebuildIfStillVisible(_ menu: NSMenu, provider: UsageProvider?) {
|
|
self.providerSwitcherUpdateToken &+= 1
|
|
let updateToken = self.providerSwitcherUpdateToken
|
|
#if DEBUG
|
|
let debounceNanoseconds = self._test_providerSwitcherMenuRebuildDebounceNanoseconds ?? (
|
|
self._test_openMenuRebuildObserver == nil ? Self.providerSwitcherMenuRebuildDebounceNanoseconds : 0)
|
|
#else
|
|
let debounceNanoseconds = Self.providerSwitcherMenuRebuildDebounceNanoseconds
|
|
#endif
|
|
#if DEBUG
|
|
let usesTaskSchedulerForTesting = self._test_openMenuRefreshYieldOverride != nil
|
|
|| self._test_openMenuRebuildObserver != nil
|
|
#else
|
|
let usesTaskSchedulerForTesting = false
|
|
#endif
|
|
if debounceNanoseconds == 0, !usesTaskSchedulerForTesting {
|
|
self.scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
|
|
menu,
|
|
provider: provider)
|
|
{ [weak self] in
|
|
guard let self else { return false }
|
|
return self.providerSwitcherUpdateToken == updateToken
|
|
}
|
|
return
|
|
}
|
|
self.scheduleOpenMenuRebuildIfStillVisible(
|
|
menu,
|
|
provider: provider,
|
|
closeHostedSubviewMenusBeforeRebuild: true,
|
|
debounceNanoseconds: debounceNanoseconds)
|
|
{ [weak self] in
|
|
guard let self else { return false }
|
|
return self.providerSwitcherUpdateToken == updateToken
|
|
}
|
|
}
|
|
|
|
private func scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
|
|
_ menu: NSMenu,
|
|
provider: UsageProvider?,
|
|
beforeRebuild: @escaping @MainActor () -> Bool)
|
|
{
|
|
let key = ObjectIdentifier(menu)
|
|
self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
|
|
let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
|
|
self.openMenuRebuildTasks.removeValue(forKey: key)?.cancel()
|
|
|
|
ProviderSwitcherTrackingRunLoopScheduler.schedule { [weak self, weak menu] in
|
|
guard let self, let menu else { return }
|
|
self.performScheduledOpenMenuRebuild(
|
|
menu,
|
|
key: key,
|
|
rebuildToken: rebuildToken,
|
|
request: ScheduledOpenMenuRebuild(
|
|
provider: provider,
|
|
shouldCloseHostedSubviewMenus: true,
|
|
beforeRebuild: beforeRebuild))
|
|
}
|
|
}
|
|
|
|
func scheduleOpenMenuRebuildIfStillVisible(
|
|
_ menu: NSMenu,
|
|
provider: UsageProvider?,
|
|
closeHostedSubviewMenusBeforeRebuild: Bool = false,
|
|
resyncReadinessBaselineAfterRebuild: Bool = false,
|
|
debounceNanoseconds: UInt64 = 0,
|
|
beforeRebuild: (@MainActor () -> Bool)? = nil)
|
|
{
|
|
let key = ObjectIdentifier(menu)
|
|
if resyncReadinessBaselineAfterRebuild {
|
|
self.pendingMenuBaselineResyncs.insert(key)
|
|
}
|
|
if closeHostedSubviewMenusBeforeRebuild {
|
|
self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
|
|
}
|
|
let shouldCloseHostedSubviewMenus = self.openMenuRebuildsClosingHostedSubviewMenus.contains(key)
|
|
let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
|
|
self.openMenuRebuildTasks[key]?.cancel()
|
|
self.openMenuRebuildTasks[key] = Task { @MainActor [weak self, weak menu] in
|
|
guard let self, let menu else { return }
|
|
#if DEBUG
|
|
if let override = self._test_openMenuRefreshYieldOverride {
|
|
await override()
|
|
} else {
|
|
await Task.yield()
|
|
}
|
|
#else
|
|
await Task.yield()
|
|
#endif
|
|
if debounceNanoseconds > 0 {
|
|
try? await Task.sleep(nanoseconds: debounceNanoseconds)
|
|
}
|
|
guard !Task.isCancelled else { return }
|
|
self.performScheduledOpenMenuRebuild(
|
|
menu,
|
|
key: key,
|
|
rebuildToken: rebuildToken,
|
|
request: ScheduledOpenMenuRebuild(
|
|
provider: provider,
|
|
shouldCloseHostedSubviewMenus: shouldCloseHostedSubviewMenus,
|
|
beforeRebuild: beforeRebuild))
|
|
}
|
|
}
|
|
|
|
private func performScheduledOpenMenuRebuild(
|
|
_ menu: NSMenu,
|
|
key: ObjectIdentifier,
|
|
rebuildToken: Int,
|
|
request: ScheduledOpenMenuRebuild)
|
|
{
|
|
guard self.openMenuRebuildRequests.isCurrent(rebuildToken, for: key) else { return }
|
|
defer {
|
|
if self.openMenuRebuildRequests.finish(rebuildToken, for: key) {
|
|
self.openMenuRebuildTasks.removeValue(forKey: key)
|
|
self.openMenuRebuildsClosingHostedSubviewMenus.remove(key)
|
|
}
|
|
}
|
|
guard self.openMenus[key] != nil else { return }
|
|
guard request.beforeRebuild?() ?? true else { return }
|
|
if request.shouldCloseHostedSubviewMenus {
|
|
self.closeHostedSubviewMenusForParentSwitch()
|
|
}
|
|
self.rebuildOpenMenuIfStillVisible(menu, provider: request.provider)
|
|
if self.pendingMenuBaselineResyncs.contains(key), !self.menuNeedsRefresh(menu) {
|
|
self.pendingMenuBaselineResyncs.remove(key)
|
|
self.resyncMenuAdjunctReadinessBaseline()
|
|
}
|
|
}
|
|
|
|
private func closeHostedSubviewMenusForParentSwitch() {
|
|
let hostedMenus = self.openMenus.values.filter { self.isHostedSubviewMenu($0) }
|
|
for hostedMenu in hostedMenus {
|
|
hostedMenu.cancelTrackingWithoutAnimation()
|
|
self.forgetClosedMenu(hostedMenu)
|
|
}
|
|
}
|
|
}
|