Sync upstream CodexBar main through 0.33.1 development

CHANGELOG.md

@@ -13,6 +13,15 @@ on Columbus Labs QuotaKit releases and product-facing changes.
   Codex account/auth hardening, MiniMax quota fixes, menu performance updates,
   merged provider-switching hang fixes, Claude probe cleanup,
   Antigravity/Alibaba/Cursor fixes, and additional Mac localizations.
+- Synced upstream CodexBar Mac improvements through `0.33.1` development,
+  including a security fix that blocks credentialed provider redirects leaving
+  the original HTTPS origin, a new Devin usage provider, Cursor legacy
+  request-quota and Full Disk Access hint fixes, Copilot unlimited chat quota
+  display, Codex cost visibility without quotas, updated Claude usage pricing
+  and web session recovery, Doubao false-exhaustion fixes, cost scanner
+  threading and cancellation overhauls, broad menu performance and
+  width-stability work, a configurable terminal app for Open Terminal, expanded
+  MiMo browser support, and Japanese localization.
 
 ## 0.32.4.4 / iOS 1.11.1 — 2026-06-08
 

CodexBarMobile/CodexBarMobile/Models/ProviderColorPalette.swift

@@ -119,6 +119,7 @@ enum ProviderColorPalette {
             (["groq", "groqcloud", "groqapi"], RawColor(red: 245 / 255, green: 104 / 255, blue: 68 / 255)),
             (["llmproxy"], RawColor(red: 36 / 255, green: 180 / 255, blue: 126 / 255)),
             (["deepgram"], RawColor(red: 0.49, green: 0.23, blue: 0.93)),
+            (["devin"], RawColor(red: 70 / 255, green: 180 / 255, blue: 130 / 255)),
         ]
 
         var table: [String: RawColor] = [:]

Sources/CodexBar/ClickToCopyOverlay.swift

@@ -1,6 +1,35 @@
 import AppKit
 import SwiftUI
 
+@MainActor
+enum MenuPasteboardCopy {
+    typealias DeferredAction = @MainActor @Sendable () -> Void
+    typealias Scheduler = @MainActor @Sendable (@escaping DeferredAction) -> Void
+    typealias Writer = @MainActor @Sendable (String) -> Void
+
+    static func perform(
+        _ text: String,
+        scheduler: Scheduler = Self.schedule,
+        writer: @escaping Writer = Self.write,
+        completion: @escaping DeferredAction = {})
+    {
+        scheduler {
+            writer(text)
+            completion()
+        }
+    }
+
+    private static func schedule(_ action: @escaping DeferredAction) {
+        DispatchQueue.main.async(execute: action)
+    }
+
+    private static func write(_ text: String) {
+        let pasteboard = NSPasteboard.general
+        pasteboard.clearContents()
+        pasteboard.setString(text, forType: .string)
+    }
+}
+
 struct ClickToCopyOverlay: NSViewRepresentable {
     let copyText: String
 
@@ -9,15 +38,25 @@ struct ClickToCopyOverlay: NSViewRepresentable {
     }
 
     func updateNSView(_ nsView: ClickToCopyView, context: Context) {
+        // Guard against no-op writes to avoid AppKit view invalidation on every
+        // parent card SwiftUI diff (each MenuCardView body re-eval runs through
+        // .overlay { ClickToCopyOverlay(...) }, which calls updateNSView even
+        // when copyText is unchanged).
+        guard nsView.copyText != self.copyText else { return }
         nsView.copyText = self.copyText
     }
 }
 
 final class ClickToCopyView: NSView {
     var copyText: String
+    private let copyAction: (String) -> Void
 
-    init(copyText: String) {
+    init(
+        copyText: String,
+        copyAction: @escaping (String) -> Void = { MenuPasteboardCopy.perform($0) })
+    {
         self.copyText = copyText
+        self.copyAction = copyAction
         super.init(frame: .zero)
         self.wantsLayer = false
     }
@@ -33,8 +72,6 @@ final class ClickToCopyView: NSView {
 
     override func mouseDown(with event: NSEvent) {
         _ = event
-        let pb = NSPasteboard.general
-        pb.clearContents()
-        pb.setString(self.copyText, forType: .string)
+        self.copyAction(self.copyText)
     }
 }

Sources/CodexBar/CostHistoryChartMenuView.swift

@@ -131,47 +131,68 @@ struct CostHistoryChartMenuView: View {
                         .lineLimit(1)
                         .truncationMode(.tail)
                         .frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
-                    ForEach(detail.rows) { row in
-                        HStack(alignment: .top, spacing: 8) {
-                            Rectangle()
-                                .fill(row.accentColor)
-                                .frame(
-                                    width: 2,
-                                    height: Self.accentHeight(for: row))
-                                .padding(.top, 1)
-
-                            VStack(alignment: .leading, spacing: 1) {
-                                Text(row.title)
-                                    .font(.caption)
-                                    .foregroundStyle(.secondary)
-                                    .lineLimit(1)
-                                    .truncationMode(.tail)
-                                    .frame(height: Self.detailTitleLineHeight, alignment: .leading)
-                                if let subtitle = row.subtitle {
-                                    Text(subtitle)
-                                        .font(.caption2)
-                                        .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                                        .lineLimit(1)
-                                        .truncationMode(.tail)
-                                        .frame(height: Self.detailSubtitleLineHeight, alignment: .leading)
+                    if model.maxRenderedBreakdownRows > 0 {
+                        ScrollView(.vertical) {
+                            VStack(alignment: .leading, spacing: Self.detailSpacing) {
+                                ForEach(detail.rows) { row in
+                                    HStack(alignment: .top, spacing: 8) {
+                                        Rectangle()
+                                            .fill(row.accentColor)
+                                            .frame(
+                                                width: 2,
+                                                height: Self.accentHeight(for: row))
+                                            .padding(.top, 1)
+
+                                        VStack(alignment: .leading, spacing: 1) {
+                                            Text(row.title)
+                                                .font(.caption)
+                                                .foregroundStyle(.secondary)
+                                                .lineLimit(1)
+                                                .truncationMode(.tail)
+                                                .frame(height: Self.detailTitleLineHeight, alignment: .leading)
+                                            if let subtitle = row.subtitle {
+                                                Text(subtitle)
+                                                    .font(.caption2)
+                                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                                                    .lineLimit(1)
+                                                    .truncationMode(.tail)
+                                                    .frame(
+                                                        height: Self.detailSubtitleLineHeight,
+                                                        alignment: .leading)
+                                            }
+                                            if let modeSubtitle = row.modeSubtitle {
+                                                Text(modeSubtitle)
+                                                    .font(.caption2)
+                                                    .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
+                                                    .lineLimit(1)
+                                                    .truncationMode(.tail)
+                                                    .frame(
+                                                        height: Self.detailSubtitleLineHeight,
+                                                        alignment: .leading)
+                                            }
+                                        }
+                                    }
+                                    .frame(height: Self.detailRowHeight(for: row), alignment: .leading)
                                 }
-                                if let modeSubtitle = row.modeSubtitle {
-                                    Text(modeSubtitle)
-                                        .font(.caption2)
-                                        .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
-                                        .lineLimit(1)
-                                        .truncationMode(.tail)
-                                        .frame(height: Self.detailSubtitleLineHeight, alignment: .leading)
+                                ForEach(
+                                    0..<max(model.maxRenderedBreakdownRows - detail.rows.count, 0),
+                                    id: \.self)
+                                { _ in
+                                    Text(" ")
+                                        .font(.caption)
+                                        .frame(height: Self.compactDetailRowHeight, alignment: .leading)
+                                        .opacity(0)
                                 }
                             }
                         }
-                        .frame(height: Self.detailRowHeight(for: row), alignment: .leading)
-                    }
-                    ForEach(0..<max(model.maxRenderedBreakdownRows - detail.rows.count, 0), id: \.self) { _ in
-                        Text(" ")
-                            .font(.caption)
-                            .frame(height: Self.compactDetailRowHeight, alignment: .leading)
-                            .opacity(0)
+                        .scrollIndicators(
+                            Self.detailRowsNeedScrolling(itemCount: detail.rows.count) ? .visible : .hidden)
+                        .frame(
+                            height: Self.detailRowsViewportHeight(
+                                maxBreakdownRows: model.maxRenderedBreakdownRows,
+                                maxRowsHeight: model.maxDetailRowsHeight),
+                            alignment: .topLeading)
+                        .id(self.selectedDateKey)
                     }
                 }
                 .frame(
@@ -211,7 +232,7 @@ struct CostHistoryChartMenuView: View {
     }
 
     private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
-    private static let maxVisibleDetailLines = 4
+    static let maxVisibleDetailLines = 4
     private static let detailPrimaryLineHeight: CGFloat = 16
     private static let detailTitleLineHeight: CGFloat = 16
     private static let detailSubtitleLineHeight: CGFloat = 13
@@ -338,8 +359,8 @@ struct CostHistoryChartMenuView: View {
     private static func renderedBreakdownRowsMetric(for entry: DailyEntry) -> (count: Int, height: CGFloat) {
         guard let breakdown = entry.modelBreakdowns, !breakdown.isEmpty else { return (0, 0) }
         let renderedRows = Array(
-            self.sortedBreakdown(breakdown)
-                .prefix(self.maxVisibleDetailLines))
+            self.orderedBreakdownItems(breakdown)
+                .prefix(self.detailViewportRowCount(itemCount: breakdown.count)))
         let height = renderedRows.reduce(CGFloat(0)) { total, item in
             total + self.detailRowHeight(hasModeSubtitle: Self.hasModeSubtitle(item))
         }
@@ -353,8 +374,18 @@ struct CostHistoryChartMenuView: View {
     private static func detailBlockHeight(maxBreakdownRows: Int, maxRowsHeight: CGFloat) -> CGFloat {
         guard maxBreakdownRows > 0 else { return self.detailPrimaryLineHeight }
         return self.detailPrimaryLineHeight +
-            maxRowsHeight +
-            (CGFloat(maxBreakdownRows) * self.detailSpacing)
+            self.detailRowsViewportHeight(
+                maxBreakdownRows: maxBreakdownRows,
+                maxRowsHeight: maxRowsHeight) +
+            self.detailSpacing
+    }
+
+    private static func detailRowsViewportHeight(
+        maxBreakdownRows: Int,
+        maxRowsHeight: CGFloat) -> CGFloat
+    {
+        guard maxBreakdownRows > 0 else { return 0 }
+        return maxRowsHeight + (CGFloat(maxBreakdownRows - 1) * self.detailSpacing)
     }
 
     private func selectionBandRect(model: Model, proxy: ChartProxy, geo: GeometryProxy) -> CGRect? {
@@ -400,10 +431,9 @@ struct CostHistoryChartMenuView: View {
         proxy: ChartProxy,
         geo: GeometryProxy)
     {
-        guard let location else {
-            if self.selectedDateKey != nil { self.selectedDateKey = nil }
-            return
-        }
+        // Keep the last hovered day selected when the pointer leaves the chart so the adjacent
+        // model-breakdown scroller remains interactive. The selection resets with the menu view.
+        guard let location else { return }
 
         guard let plotAnchor = proxy.plotFrame else { return }
         let plotFrame = geo[plotAnchor]
@@ -457,8 +487,7 @@ struct CostHistoryChartMenuView: View {
         guard let entry = model.entriesByDateKey[key] else { return [] }
         guard let breakdown = entry.modelBreakdowns, !breakdown.isEmpty else { return [] }
 
-        return Self.sortedBreakdown(breakdown)
-            .prefix(Self.maxVisibleDetailLines)
+        return Self.orderedBreakdownItems(breakdown)
             .enumerated()
             .map { index, item in
                 DetailRow(
@@ -470,7 +499,7 @@ struct CostHistoryChartMenuView: View {
             }
     }
 
-    private static func sortedBreakdown(
+    static func orderedBreakdownItems(
         _ breakdown: [CostUsageDailyReport.ModelBreakdown]) -> [CostUsageDailyReport.ModelBreakdown]
     {
         breakdown.sorted { lhs, rhs in
@@ -486,6 +515,14 @@ struct CostHistoryChartMenuView: View {
         }
     }
 
+    static func detailViewportRowCount(itemCount: Int) -> Int {
+        min(max(itemCount, 0), self.maxVisibleDetailLines)
+    }
+
+    static func detailRowsNeedScrolling(itemCount: Int) -> Bool {
+        itemCount > self.maxVisibleDetailLines
+    }
+
     private func modelBreakdownTotalSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
         UsageFormatter.modelCostDetail(
             item.modelName,

Sources/CodexBar/KeychainPromptCoordinator.swift

@@ -65,6 +65,34 @@ enum KeychainPromptCoordinator {
         BrowserCookieKeychainPromptHandler.handler = { context in
             self.presentBrowserCookiePrompt(context)
         }
+        self.disableKeychainForUnbundledExecutableIfNeeded()
+    }
+
+    private static let unbundledExecutableCheckLock = NSLock()
+    private nonisolated(unsafe) static var didCheckUnbundledExecutable = false
+
+    static func disableKeychainForUnbundledExecutableIfNeeded() {
+        self.unbundledExecutableCheckLock.lock()
+        guard !self.didCheckUnbundledExecutable else {
+            self.unbundledExecutableCheckLock.unlock()
+            return
+        }
+        self.didCheckUnbundledExecutable = true
+        self.unbundledExecutableCheckLock.unlock()
+
+        let executablePath = Bundle.main.executableURL?.path ?? ""
+        guard Self.isUnbundledCodexBarExecutable(executablePath) else { return }
+        KeychainAccessGate.forceDisabledForProcess(reason: "unbundled-executable")
+        Self.log.warning(
+            "Unbundled CodexBar executable detected; disabling keychain access to avoid repeated prompts",
+            metadata: ["doc": "docs/DEVELOPMENT_SETUP.md"])
+    }
+
+    static func isUnbundledCodexBarExecutable(_ executablePath: String) -> Bool {
+        guard executablePath.hasPrefix("/") else { return false }
+        let executableURL = URL(fileURLWithPath: executablePath).standardizedFileURL
+        return executableURL.lastPathComponent == "CodexBar"
+            && !executableURL.pathComponents.contains(where: { $0.hasSuffix(".app") })
     }
 
     private static func presentKeychainPrompt(_ context: KeychainPromptContext) {

Sources/CodexBar/MenuCardView+ModelHelpers.swift

@@ -29,6 +29,13 @@ extension UsageMenuCardView.Model {
             self.placeholder != nil
     }
 
+    var usesStackedDetailLayout: Bool {
+        !self.metrics.isEmpty ||
+            self.creditsText != nil ||
+            self.providerCost != nil ||
+            self.tokenUsage != nil
+    }
+
     static func progressColor(for provider: UsageProvider) -> Color {
         if provider == .cursor || provider == .elevenlabs {
             return Color(nsColor: .labelColor)
@@ -52,7 +59,7 @@ extension UsageMenuCardView.Model {
         }
 
         if input.snapshot == nil, !input.isRefreshing, input.lastError == nil {
-            return L("No usage yet")
+            return self.hasLocalCodexTokenUsage(input) ? nil : L("No usage yet")
         }
 
         return nil
@@ -70,6 +77,12 @@ extension UsageMenuCardView.Model {
         return lastError
     }
 
+    private static func hasLocalCodexTokenUsage(_ input: Input) -> Bool {
+        input.provider == .codex &&
+            input.tokenCostUsageEnabled &&
+            self.tokenUsageSnapshot(input: input) != nil
+    }
+
     private static func shouldShowRateLimitsUnavailablePlaceholder(input: Input, lastError: String? = nil) -> Bool {
         let currentError = lastError ?? input.lastError
         if let currentError = currentError?.trimmingCharacters(in: .whitespacesAndNewlines),