Sync upstream CodexBar through 02b4ba278

CHANGELOG.md

@@ -18,7 +18,7 @@ on Columbus Labs QuotaKit releases and product-facing changes.
 ### Changed
 - Menu bar: remove status-item hover tooltips while retaining VoiceOver titles.
 - Cost displays: use consistent labels while preserving reported-versus-estimated provenance in settings and per-value hints.
-- Synced upstream CodexBar changes through `f8636cb37`, including OpenCode Go source scoping and sub-1% usage accuracy, macOS 14 TaskLocal launch stability, weekly progress selection, custom-layout icon tinting, widget cost-row compaction, and Command Code contrast while preserving QuotaKit release ownership, CloudKit setup, config paths, and iOS build numbers.
+- Synced upstream CodexBar changes through `02b4ba278`, including Claude weekly-window ordering and fallback accuracy, Kimi weekly duration accuracy, Ollama session reuse, safer automatic Safari-cookie handling, LongCat Firefox imports, localized session equivalents, stacked menu-title alignment, WidgetKit refresh-loop prevention, and Linux Alibaba Token Plan support while preserving QuotaKit release ownership, CloudKit setup, config paths, and iOS build numbers.
 
 ### Fixed
 - Refresh: prevent macOS 14 launch crashes caused by TaskLocal task-allocation corruption.
@@ -35,6 +35,7 @@ on Columbus Labs QuotaKit releases and product-facing changes.
 - Codex: exclude parent-copied prefixes from compact subagent usage when the fork boundary matches the parent snapshot.
 - Usage & Spend: render share-card PNG exports without black backgrounds and keep complete model rows visible beside incomplete sources.
 - ElevenLabs: clamp character and voice-slot usage percentages at 100% during overage.
+- Ollama: reuse validated browser sessions and skip inaccessible Safari cookies during automatic fallback while retaining explicit permission guidance.
 
 ## 0.32.4.12 / iOS 1.11.3 — 2026-07-17
 

Sources/CodexBar/Localization.swift

@@ -214,7 +214,22 @@ func L(_ key: String, language: String) -> String {
 }
 
 func codexBarLocalizedLocale() -> Locale {
-    let language = resolvedAppLanguage()
+    codexBarLocale(forLanguage: resolvedAppLanguage())
+}
+
+/// Returns the locale of the resource bundle currently selected by `L`.
+///
+/// This can differ from `Locale.current` when the app falls back to a supported language. Plural
+/// formatting must use this locale so it follows the same language as the resolved strings.
+func codexBarLocalizedResourceLocale() -> Locale {
+    let bundleURL = localizedBundle().bundleURL
+    guard bundleURL.pathExtension == "lproj" else {
+        return codexBarLocalizedLocale()
+    }
+    return codexBarLocale(forLanguage: bundleURL.deletingPathExtension().lastPathComponent)
+}
+
+private func codexBarLocale(forLanguage language: String) -> Locale {
     guard !language.isEmpty else { return .current }
     let normalized = language.lowercased()
     if normalized == "ar" || normalized.hasPrefix("ar-") {

Sources/CodexBar/MenuBarLayoutRenderer.swift

@@ -91,6 +91,7 @@ final class MenuBarLayoutTitleCache {
 @MainActor
 final class MenuBarLayoutRenderer {
     private static let missingValue = "–"
+    private static let stackedBaselineOffset: CGFloat = -3 // Center multi-line NSStatusBarButton titles.
 
     private struct TokenStyle {
         let font: NSFont
@@ -138,11 +139,14 @@ final class MenuBarLayoutRenderer {
             paragraphStyle.maximumLineHeight = 9.5
             paragraphStyle.lineSpacing = -1
         }
-        let attributes: [NSAttributedString.Key: Any] = [
+        var attributes: [NSAttributedString.Key: Any] = [
             .font: font,
             .foregroundColor: foregroundColor,
             .paragraphStyle: paragraphStyle,
         ]
+        if isStacked {
+            attributes[.baselineOffset] = Self.stackedBaselineOffset
+        }
         let result = NSMutableAttributedString()
         var accessibilityLines: [String] = []
 

Sources/CodexBar/MenuCardView.swift

@@ -1408,7 +1408,11 @@ extension UsageMenuCardView.Model {
                     primaryPaceOnTop = paceDetail.paceOnTop
                 }
             }
-        } else if let paceDetail = Self.resetWindowPaceDetail(window: primary, input: input) {
+        } else if let paceDetail = Self.resetWindowPaceDetail(
+            window: primary,
+            input: input,
+            pace: input.provider == .kimi ? input.weeklyPace : nil)
+        {
             primaryDetailLeft = paceDetail.leftLabel
             primaryDetailRight = paceDetail.rightLabel
             primaryPacePercent = paceDetail.pacePercent
@@ -1468,12 +1472,21 @@ extension UsageMenuCardView.Model {
         title: String? = nil,
         zaiTimeDetail: String?) -> Metric
     {
-        var paceDetail = Self.weeklyPaceDetail(
-            provider: input.provider,
-            window: weekly,
-            now: input.now,
-            pace: input.weeklyPace,
-            showUsed: input.usageBarsShowUsed)
+        // Kimi's secondary slot is its 5-hour rate limit rather than a weekly window.
+        var paceDetail = if input.provider == .kimi {
+            Self.sessionPaceDetail(
+                provider: input.provider,
+                window: weekly,
+                now: input.now,
+                showUsed: input.usageBarsShowUsed)
+        } else {
+            Self.weeklyPaceDetail(
+                provider: input.provider,
+                window: weekly,
+                now: input.now,
+                pace: input.weeklyPace,
+                showUsed: input.usageBarsShowUsed)
+        }
         var weeklyResetText = Self.resetText(for: weekly, style: input.resetTimeDisplayStyle, now: input.now)
         var weeklyDetailText: String? = input.provider == .zai ? zaiTimeDetail : nil
         if input.provider == .warp,

Sources/CodexBar/PreferencesProvidersPane.swift

@@ -539,8 +539,8 @@ struct ProvidersPane: View {
             tokenError = nil
         }
 
-        // Abacus uses primary for monthly credits (no secondary window)
-        let paceWindow = provider == .abacus ? snapshot?.primary : snapshot?.secondary
+        // Abacus and Kimi carry their long-cadence window in primary rather than secondary.
+        let paceWindow = provider == .abacus || provider == .kimi ? snapshot?.primary : snapshot?.secondary
         let weeklyPace = if let codexProjection,
                             let weekly = codexProjection.rateWindow(for: .weekly)
         {

Sources/CodexBar/Providers/Ollama/OllamaProviderImplementation.swift

@@ -97,7 +97,21 @@ struct OllamaProviderImplementation: ProviderImplementation {
                 binding: cookieBinding,
                 options: cookieOptions,
                 isVisible: nil,
-                onChange: nil),
+                onChange: nil,
+                trailingText: {
+                    guard context.settings.ollamaUsageDataSource != .api else { return nil }
+                    return ProviderCookieRefreshAction.trailingText(
+                        provider: .ollama,
+                        cookieSource: context.settings.ollamaCookieSource,
+                        context: context)
+                },
+                trailingActions: [
+                    ProviderCookieRefreshAction.descriptor(
+                        provider: .ollama,
+                        cookieSource: { context.settings.ollamaCookieSource },
+                        additionalVisibility: { context.settings.ollamaUsageDataSource != .api },
+                        context: context),
+                ]),
         ]
     }
 

Sources/CodexBar/Providers/Shared/ProviderCookieRefreshAction.swift

@@ -11,13 +11,14 @@ enum ProviderCookieRefreshAction {
     static func descriptor(
         provider: UsageProvider,
         cookieSource: @escaping () -> ProviderCookieSource,
+        additionalVisibility: @escaping () -> Bool = { true },
         context: ProviderSettingsContext) -> ProviderSettingsActionDescriptor
     {
         ProviderSettingsActionDescriptor(
             id: "\(provider.rawValue)-reimport-cookie",
             title: "Refresh",
             style: .bordered,
-            isVisible: { cookieSource() == .auto },
+            isVisible: { cookieSource() == .auto && additionalVisibility() },
             perform: {
                 await self.perform(provider: provider, context: context)
             })

Sources/CodexBar/StatusItemController+MenuCardModel.swift

@@ -88,8 +88,8 @@ extension StatusItemController {
 
         let sourceLabel = surface == .liveCard ? self.store.sourceLabel(for: target) : nil
         let kiloAutoMode = target == .kilo && self.settings.kiloUsageDataSource == .auto
-        // Abacus uses primary for monthly credits (no secondary window)
-        let paceWindow = target == .abacus ? snapshot?.primary : snapshot?.secondary
+        // Abacus and Kimi carry their long-cadence window in primary rather than secondary.
+        let paceWindow = target == .abacus || target == .kimi ? snapshot?.primary : snapshot?.secondary
         let sessionEquivalentHistorySelection = self.sessionEquivalentHistorySelection(
             provider: target,
             snapshot: snapshot,

Sources/CodexBar/UsagePaceText.swift

@@ -39,19 +39,21 @@ enum UsagePaceText {
 
     static func sessionEquivalentDetail(forecast: SessionEquivalentForecast) -> SessionEquivalentDetail {
         let displayedEstimate = Self.boundedFullWindowCount(forecast.estimatedWindowsToExhaustWeekly)
-        let numberText = String.localizedStringWithFormat(
-            L("≈%d full 5h windows of weekly left · %d windows until reset"),
-            displayedEstimate,
-            forecast.windowsUntilReset)
+        let formattingLocale = codexBarLocalizedResourceLocale()
+        let numberText = String(
+            format: L("≈%d full 5h windows of weekly left · %d windows until reset"),
+            locale: formattingLocale,
+            arguments: [displayedEstimate, forecast.windowsUntilReset])
         let verdictText: String
         if forecast.estimatedWindowsToExhaustWeekly >= forecast.availableWindowsUntilReset {
             verdictText = L("Weekly cannot run out before reset at this pace")
         } else {
             let windowsEarly = Self.boundedWindowCount(
                 forecast.availableWindowsUntilReset - forecast.estimatedWindowsToExhaustWeekly)
-            verdictText = String.localizedStringWithFormat(
-                L("Weekly can run out ≈%d windows early"),
-                max(1, windowsEarly))
+            verdictText = String(
+                format: L("Weekly can run out ≈%d windows early"),
+                locale: formattingLocale,
+                arguments: [max(1, windowsEarly)])
         }
         return SessionEquivalentDetail(
             verdictText: verdictText,
@@ -151,14 +153,18 @@ enum UsagePaceText {
     }
 
     static func sessionPace(provider: UsageProvider, window: RateWindow, now: Date) -> UsagePace? {
-        guard provider == .codex || provider == .claude || provider == .ollama || provider == .antigravity
+        guard provider == .codex || provider == .claude || provider == .ollama || provider == .antigravity ||
+            provider == .kimi
         else { return nil }
         if provider == .ollama, window.windowMinutes == nil {
             return nil
         }
         if provider == .antigravity, let windowMinutes = window.windowMinutes, windowMinutes != 300 {
             return nil
         }
+        if provider == .kimi, window.windowMinutes != KimiProviderDescriptor.sessionWindowMinutes {
+            return nil
+        }
         guard window.remainingPercent > 0 else { return nil }
         guard let pace = UsagePace.weekly(window: window, now: now, defaultWindowMinutes: 300) else { return nil }
         guard pace.expectedUsedPercent >= 3 else { return nil }

Sources/CodexBarCLI/CLIRenderer.swift

@@ -544,10 +544,20 @@ enum CLIRenderer {
         now: Date = Date()) -> ProviderPacePayload?
     {
         let primary = snapshot.primary.flatMap {
-            self.pacePayload(provider: provider, window: $0, kind: .session, now: now)
+            self.pacePayload(
+                provider: provider,
+                window: $0,
+                kind: self.paceKind(provider: provider, fallback: .session),
+                weeklyWorkDays: weeklyWorkDays,
+                now: now)
         }
         let secondary = snapshot.secondary.flatMap {
-            self.pacePayload(provider: provider, window: $0, kind: .weekly, weeklyWorkDays: weeklyWorkDays, now: now)
+            self.pacePayload(
+                provider: provider,
+                window: $0,
+                kind: self.paceKind(provider: provider, fallback: .weekly),
+                weeklyWorkDays: weeklyWorkDays,
+                now: now)
         }
         guard primary != nil || secondary != nil else { return nil }
         return ProviderPacePayload(primary: primary, secondary: secondary)
@@ -577,7 +587,7 @@ enum CLIRenderer {
                 provider: provider,
                 title: labels.primary,
                 window: primary,
-                paceKind: .session,
+                paceKind: self.paceKind(provider: provider, fallback: .session),
                 context: context,
                 now: now,
                 lines: &lines)
@@ -609,7 +619,7 @@ enum CLIRenderer {
             provider: provider,
             title: labels.secondary,
             window: weekly,
-            paceKind: .weekly,
+            paceKind: self.paceKind(provider: provider, fallback: .weekly),
             context: context,
             now: now,
             lines: &lines)
@@ -1067,13 +1077,25 @@ enum CLIRenderer {
         func supports(provider: UsageProvider) -> Bool {
             switch self {
             case .session:
-                provider == .codex || provider == .claude || provider == .ollama
+                provider == .codex || provider == .claude || provider == .ollama || provider == .kimi
             case .weekly:
-                provider == .codex || provider == .claude || provider == .opencode || provider == .ollama
+                provider == .codex || provider == .claude || provider == .opencode || provider == .ollama ||
+                    provider == .kimi
             }
         }
     }
 
+    private static func paceKind(provider: UsageProvider, fallback: PaceKind) -> PaceKind {
+        guard provider == .kimi else { return fallback }
+        // Kimi stores weekly in primary and its rate limit in secondary, opposite the legacy CLI slot convention.
+        switch fallback {
+        case .session:
+            return .weekly
+        case .weekly:
+            return .session
+        }
+    }
+
     private static func computePace(
         provider: UsageProvider,
         window: RateWindow,
@@ -1082,6 +1104,16 @@ enum CLIRenderer {
         now: Date) -> UsagePace?
     {
         guard kind.supports(provider: provider) else { return nil }
+        if provider == .kimi {
+            let supportsWindow = switch kind {
+            case .session:
+                window.windowMinutes == KimiProviderDescriptor.sessionWindowMinutes
+            case .weekly:
+                ProviderDescriptorRegistry.descriptor(for: provider).pace
+                    .supportsResetWindowPace(window: window, now: now)
+            }
+            guard supportsWindow else { return nil }
+        }
         // Only pace a real session window here; Claude w/o 5-hour data falls a 7-day window into primary.
         if case .session = kind, let minutes = window.windowMinutes, minutes > 300 {
             return nil

Sources/CodexBarCLI/CLIUsageCommand.swift

@@ -699,6 +699,13 @@ extension CodexBarCLI {
         {
             return false
         }
+        if provider == .alibabatokenplan,
+           settings?.alibabaTokenPlan?.cookieSource == .manual
+        {
+            // The Alibaba/Qwen Token Plan fetch is plain URLSession + cookies; only browser
+            // cookie auto-import needs macOS, so a manual cookie header works off macOS too.
+            return false
+        }
         #if os(Linux)
         if provider == .cursor,
            settings?.cursor?.cookieSource != .off

Sources/CodexBarCore/Providers/Claude/ClaudeOAuth/ClaudeOAuthUsageFetcher.swift

@@ -208,18 +208,14 @@ struct OAuthUsageResponse: Decodable {
         in container: KeyedDecodingContainer<DynamicCodingKey>,
         keys: [String]) -> (window: OAuthUsageWindow?, sourceKey: String?)
     {
-        var firstNullKey: String?
         for keyName in keys {
             guard let key = DynamicCodingKey(stringValue: keyName) else { continue }
             guard container.contains(key) else { continue }
             if let value = try? container.decodeIfPresent(OAuthUsageWindow.self, forKey: key) {
                 return (value, keyName)
             }
-            if firstNullKey == nil {
-                firstNullKey = keyName
-            }
         }
-        return (nil, firstNullKey)
+        return (nil, nil)
     }
 
     private static func decodeValue<T: Decodable>(