import CodexBarCoreimport SwiftUI extension UsageMenuCardView.Model {    struct PaceDetail {        let leftLabel: String        let rightLabel: String?        let pacePercent: Double?        let paceOnTop: Bool    }     static func redactedMetricDetail(_ detail: String?, provider: UsageProvider, metricID: String) -> String? {        guard let detail else { return nil }        guard provider == .litellm,              metricID == "secondary",              detail.hasPrefix("Team "),              let separator = detail.range(of: ": ", options: .backwards)        else {            return PersonalInfoRedactor.redactEmails(in: detail, isEnabled: true)        }        return PersonalInfoRedactor.redactEmails(in: "Team\(detail[separator.lowerBound...])", isEnabled: true)    }     static func redactedMetrics(        _ metrics: [Metric],        provider: UsageProvider,        hidePersonalInfo: Bool) -> [Metric]    {        guard hidePersonalInfo else { return metrics }        return metrics.map { metric in            Metric(                id: metric.id,                title: PersonalInfoRedactor.redactEmails(in: metric.title, isEnabled: true) ?? metric.title,                percent: metric.percent,                percentStyle: metric.percentStyle,                statusText: PersonalInfoRedactor.redactEmails(in: metric.statusText, isEnabled: true),                resetText: PersonalInfoRedactor.redactEmails(in: metric.resetText, isEnabled: true),                detailText: Self.redactedMetricDetail(                    metric.detailText,                    provider: provider,                    metricID: metric.id),                detailLeftText: PersonalInfoRedactor.redactEmails(in: metric.detailLeftText, isEnabled: true),                detailRightText: PersonalInfoRedactor.redactEmails(in: metric.detailRightText, isEnabled: true),                pacePercent: metric.pacePercent,                paceOnTop: metric.paceOnTop,                warningMarkerPercents: metric.warningMarkerPercents,                workdayMarkerPercents: metric.workdayMarkerPercents,                cardStyle: metric.cardStyle,                sessionEquivalentDetail: metric.sessionEquivalentDetail)        }    }     static func usageNotes(input: Input) -> [String] {        let subscriptionNotes = self.subscriptionMetadataNotes(snapshot: input.snapshot, provider: input.provider)         if input.provider == .sub2api {            return self.sub2APIUsageNotes(input.snapshot?.sub2APIUsage) + subscriptionNotes        }         if input.provider == .kiro {            return self.kiroUsageNotes(input: input) + subscriptionNotes        }         if input.provider == .kilo {            var notes = Self.kiloLoginDetails(snapshot: input.snapshot)            let resolvedSource = input.sourceLabel?                .trimmingCharacters(in: .whitespacesAndNewlines)                .lowercased()            if input.kiloAutoMode,               resolvedSource == "cli",               !notes.contains(where: { $0.caseInsensitiveCompare("Using CLI fallback") == .orderedSame })            {                notes.append(L("Using CLI fallback"))            }            return notes + subscriptionNotes        }         if input.provider == .mimo, input.snapshot != nil {            return Self.mimoUsageNotes(input: input, subscriptionNotes: subscriptionNotes)        }         if let notes = self.apiProviderUsageNotes(input: input) {            return notes + subscriptionNotes        }         guard input.provider == .openrouter,              let openRouter = input.snapshot?.openRouterUsage        else {            return subscriptionNotes        }         var notes = Self.openRouterSpendNotes(openRouter)        switch openRouter.keyQuotaStatus {        case .available:            break        case .noLimitConfigured:            notes.append(L("No limit set for the API key"))        case .unavailable:            notes.append(L("API key limit unavailable right now"))        }        return notes + subscriptionNotes    }     var isOverviewErrorOnly: Bool {        self.subtitleStyle == .error &&            self.metrics.isEmpty &&            self.usageNotes.isEmpty &&            self.openAIAPIUsage == nil &&            self.inlineUsageDashboard == nil &&            self.creditsRemaining == nil &&            self.providerCost == nil &&            self.tokenUsage == nil &&            self.placeholder == nil    }     var hasUsageContent: Bool {        !self.metrics.isEmpty ||            !self.usageNotes.isEmpty ||            self.openAIAPIUsage != nil ||            self.inlineUsageDashboard != nil ||            self.codexResetCredits != nil ||            self.placeholder != nil    }     var usesStackedDetailLayout: Bool {        !self.metrics.isEmpty ||            self.creditsText != nil ||            self.codexResetCredits != nil ||            self.providerCost != nil ||            self.tokenUsage != nil    }     func hasCompatibleTrackedLayout(with candidate: Self) -> Bool {        self.hasCompatibleTrackedLayout(with: candidate, includeMetrics: true)    }     func hasCompatibleTrackedLayoutIgnoringMetrics(with candidate: Self) -> Bool {        self.hasCompatibleTrackedLayout(with: candidate, includeMetrics: false)    }     func hasCompatibleTrackedMetricSubset(of candidate: Self) -> Bool {        guard self.metrics.count < candidate.metrics.count,              self.hasCompatibleTrackedLayoutIgnoringMetrics(with: candidate)        else {            return false        }        return self.metrics.allSatisfy { metric in            candidate.metrics.contains { Self.hasCompatibleMetricLayout(metric, $0) }        }    }     private func hasCompatibleTrackedLayout(with candidate: Self, includeMetrics: Bool) -> Bool {        guard self.provider == candidate.provider,              !includeMetrics || self.metrics.count == candidate.metrics.count,              self.usageNotes == candidate.usageNotes,              (self.openAIAPIUsage == nil) == (candidate.openAIAPIUsage == nil),              Self.hasCompatibleCreditsLayout(                  currentText: self.creditsText,                  currentRemaining: self.creditsRemaining,                  candidateText: candidate.creditsText,                  candidateRemaining: candidate.creditsRemaining),              self.creditsHintText == candidate.creditsHintText,              self.codexResetCredits == candidate.codexResetCredits,              self.placeholder == candidate.placeholder,              Self.hasCompatibleDashboardLayout(self.inlineUsageDashboard, candidate.inlineUsageDashboard),              Self.hasCompatibleProviderCostLayout(self.providerCost, candidate.providerCost),              Self.hasCompatibleTokenUsageLayout(self.tokenUsage, candidate.tokenUsage)        else {            return false        }         guard includeMetrics else { return true }        return zip(self.metrics, candidate.metrics).allSatisfy(Self.hasCompatibleMetricLayout)    }     private static func hasCompatibleMetricLayout(_ current: Metric, _ candidate: Metric) -> Bool {        current.id == candidate.id &&            current.title == candidate.title &&            current.percentStyle == candidate.percentStyle &&            (current.statusText == nil) == (candidate.statusText == nil) &&            (current.resetText == nil) == (candidate.resetText == nil) &&            (current.detailText == nil) == (candidate.detailText == nil) &&            (current.detailLeftText == nil) == (candidate.detailLeftText == nil) &&            (current.detailRightText == nil) == (candidate.detailRightText == nil) &&            current.cardStyle == candidate.cardStyle    }     private static func hasCompatibleCreditsLayout(        currentText: String?,        currentRemaining: Double?,        candidateText: String?,        candidateRemaining: Double?) -> Bool    {        switch (currentText, candidateText) {        case (nil, nil):            return true        case let (currentText?, candidateText?):            guard (currentRemaining == nil) == (candidateRemaining == nil) else { return false }            // Numeric balances render as a fixed single line beside the full-scale label.            // Multiline workspace balances retain their measured text until the menu reopens.            return currentRemaining != nil || currentText == candidateText        default:            return false        }    }     private static func hasCompatibleDashboardLayout(        _ current: InlineUsageDashboardModel?,        _ candidate: InlineUsageDashboardModel?) -> Bool    {        switch (current, candidate) {        case (nil, nil):            true        case let (current?, candidate?):            current.valueStyle == candidate.valueStyle &&                current.kpis.count == candidate.kpis.count &&                current.points.count == candidate.points.count &&                current.detailLines.count == candidate.detailLines.count &&                zip(current.kpis, candidate.kpis).allSatisfy {                    $0.title == $1.title && $0.emphasis == $1.emphasis                } &&                zip(current.points, candidate.points).allSatisfy {                    $0.id == $1.id && $0.label == $1.label                }        default:            false        }    }     private static func hasCompatibleProviderCostLayout(        _ current: ProviderCostSection?,        _ candidate: ProviderCostSection?) -> Bool    {        switch (current, candidate) {        case (nil, nil):            true        case let (current?, candidate?):            current.title == candidate.title &&                (current.percentUsed == nil) == (candidate.percentUsed == nil) &&                (current.percentLine == nil) == (candidate.percentLine == nil) &&                (current.personalSpendLine == nil) == (candidate.personalSpendLine == nil)        default:            false        }    }     private static func hasCompatibleTokenUsageLayout(        _ current: TokenUsageSection?,        _ candidate: TokenUsageSection?) -> Bool    {        switch (current, candidate) {        case (nil, nil):            true        case let (current?, candidate?):            current.hintLine == candidate.hintLine &&                current.errorLine == candidate.errorLine &&                (current.meteredLine == nil) == (candidate.meteredLine == nil) &&                current.comparisonLines.count == candidate.comparisonLines.count        default:            false        }    }     static func progressColor(for provider: UsageProvider) -> Color {        if provider == .elevenlabs {            return Color(nsColor: .labelColor)        }         let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color        return Color(red: color.red, green: color.green, blue: color.blue)    }     static func rateWindowLabels(        input: Input,        snapshot: UsageSnapshot) -> (primary: String, secondary: String, tertiary: String, showsTertiary: Bool)    {        if input.provider == .factory, snapshot.tertiary != nil {            return ("5-hour", L("Weekly"), L("Monthly"), true)        }        // Legacy request-based Cursor plans track a request quota, not the token-based "Total" pool.        let primaryLabel = if input.provider == .cursor, snapshot.cursorRequests != nil {            "Requests"        } else if input.provider == .grok {            GrokProviderDescriptor.primaryLabel(window: snapshot.primary, now: input.now) ?? input.metadata.sessionLabel        } else if input.provider == .doubao {            DoubaoProviderDescriptor.primaryLabel(window: snapshot.primary) ?? input.metadata.sessionLabel        } else if input.provider == .sub2api {            Sub2APIProviderDescriptor.primaryLabel(details: snapshot.sub2APIUsage) ?? input.metadata.sessionLabel        } else {            input.metadata.sessionLabel        }        return (            L(primaryLabel),            L(input.metadata.weeklyLabel),            input.metadata.opusLabel.map(L) ?? L("Sonnet"),            input.metadata.supportsOpus)    }     static func sub2APIUsageNotes(_ usage: Sub2APIUsageDetails?) -> [String] {        guard let usage else { return [] }        var notes: [String] = []        if let balance = usage.balance {            notes.append("\(L("Balance")): \(UsageFormatter.currencyString(balance, currencyCode: usage.unit))")        }        if let today = usage.today {            notes.append("\(L("Today")): \(self.sub2APITotalsText(today, unit: usage.unit))")        }        if let total = usage.total {            notes.append("\(L("Total")): \(self.sub2APITotalsText(total, unit: usage.unit))")        }        return notes    }     private static func sub2APITotalsText(_ totals: Sub2APIUsageDetails.Totals, unit: String) -> String {        "\(UsageFormatter.tokenCountString(totals.requests)) \(L("requests")) · " +            "\(UsageFormatter.tokenCountString(totals.totalTokens)) \(L("tokens")) · " +            UsageFormatter.currencyString(totals.actualCostUSD, currencyCode: unit)    }     static func resetText(        for window: RateWindow,        style: ResetTimeDisplayStyle,        now: Date) -> String?    {        UsageFormatter.resetLine(for: window, style: style, now: now)    }     static func placeholder(input: Input) -> String? {        if self.shouldShowRateLimitsUnavailablePlaceholder(input: input) {            return L("Limits not available")        }         if input.snapshot == nil, !input.isRefreshing, input.lastError == nil {            return self.hasLocalCodexTokenUsage(input) ? nil : L("No usage yet")        }         return nil    }     static func lastError(input: Input) -> String? {        guard let lastError = input.lastError?.trimmingCharacters(in: .whitespacesAndNewlines),              !lastError.isEmpty        else {            return nil        }        // Local Codex session costs are independent from OAuth, CLI quota, and OpenAI web        // dashboard access. Do not present a failed account-level quota fetch as a failure of        // a valid local API-key ledger.        if input.codexLocalSessionCostLedgerEnabled,           self.hasLocalCodexTokenUsage(input),           self.isRemoteCodexQuotaFetchError(lastError)        {            return nil        }        if self.shouldShowRateLimitsUnavailablePlaceholder(input: input, lastError: lastError) {            return nil        }        return lastError    }     static func dashboardHint(error: String?) -> String? {        guard let error, !error.isEmpty else { return nil }        return error    }     static func mimoUsageNotes(input: Input, subscriptionNotes: [String]) -> [String] {        let source = input.sourceLabel?            .trimmingCharacters(in: .whitespacesAndNewlines)            .lowercased()        guard source != "local" else { return [] }        return [            L("Balance updates in near-real time (up to 5 min lag)"),            L("Daily billing data finalizes at 07:00 UTC"),        ] + subscriptionNotes    }     static func subscriptionMetadataNotes(snapshot: UsageSnapshot?, provider: UsageProvider) -> [String] {        guard let snapshot else { return [] }        if let renewsAt = snapshot.subscriptionRenewsAt {            return [String(format: L("Renews: %@"), self.subscriptionDateString(renewsAt, provider: provider))]        }        if let expiresAt = snapshot.subscriptionExpiresAt {            return [String(format: L("Plan expires: %@"), self.subscriptionDateString(expiresAt, provider: provider))]        }        return []    }     private static func subscriptionDateString(_ date: Date, provider: UsageProvider) -> String {        let formatter = DateFormatter()        formatter.locale = Locale.current        formatter.timeZone = self.subscriptionDateTimeZone(provider: provider)        formatter.setLocalizedDateFormatFromTemplate("MMM d, yyyy")        return formatter.string(from: date)    }     private static func subscriptionDateTimeZone(provider: UsageProvider) -> TimeZone {        switch provider {        case .minimax:            TimeZone(identifier: "Asia/Shanghai") ?? .current        default:            .current        }    }     static func poeBalanceDetailText(input: Input) -> String? {        guard input.provider == .poe else { return nil }        return StatusItemController.poeBalanceDisplayText(snapshot: input.snapshot)    }     private static func hasLocalCodexTokenUsage(_ input: Input) -> Bool {        input.provider == .codex &&            input.tokenCostUsageEnabled &&            self.tokenUsageSnapshot(input: input) != nil    }     private static func isRemoteCodexQuotaFetchError(_ error: String) -> Bool {        error.localizedCaseInsensitiveContains("Codex usage is temporarily unavailable")    }     private static func shouldShowRateLimitsUnavailablePlaceholder(input: Input, lastError: String? = nil) -> Bool {        let currentError = lastError ?? input.lastError        if let currentError = currentError?.trimmingCharacters(in: .whitespacesAndNewlines),           !currentError.isEmpty,           !UsageError.isNoRateLimitsFoundDescription(currentError),           !ClaudeStatusProbe.isSubscriptionQuotaUnavailableDescription(currentError)        {            return false        }        if input.limitsAvailability?.isUnavailable == true {            return true        }        return self.rateLimitsUnavailable(input: input, lastError: currentError)    }     private static func rateLimitsUnavailable(input: Input, lastError: String? = nil) -> Bool {        UsageLimitsAvailability.resolve(            provider: input.provider,            snapshot: input.snapshot,            account: input.account,            lastErrorDescription: lastError ?? input.lastError)            .isUnavailable    }     static func sessionPaceDetail(        provider: UsageProvider,        window: RateWindow,        now: Date,        showUsed: Bool) -> PaceDetail?    {        guard let detail = UsagePaceText.sessionDetail(provider: provider, window: window, now: now) else { return nil }        let expectedUsed = detail.expectedUsedPercent        let actualUsed = window.usedPercent        let expectedPercent = showUsed ? expectedUsed : (100 - expectedUsed)        let actualPercent = showUsed ? actualUsed : (100 - actualUsed)        if expectedPercent.isFinite == false || actualPercent.isFinite == false {            return nil        }        let paceOnTop = actualUsed <= expectedUsed        let pacePercent: Double? = if detail.stage == .onTrack {            nil        } else {            expectedPercent        }        return PaceDetail(            leftLabel: detail.leftLabel,            rightLabel: detail.rightLabel,            pacePercent: pacePercent,            paceOnTop: paceOnTop)    }     static func weeklyPaceDetail(        provider: UsageProvider,        window: RateWindow,        now: Date,        pace: UsagePace?,        showUsed: Bool) -> PaceDetail?    {        guard let pace, window.remainingPercent > 0 else { return nil }        let detail = UsagePaceText.weeklyDetail(provider: provider, pace: pace, now: now)        let expectedUsed = detail.expectedUsedPercent        let actualUsed = window.usedPercent        let expectedPercent = showUsed ? expectedUsed : (100 - expectedUsed)        let actualPercent = showUsed ? actualUsed : (100 - actualUsed)        if expectedPercent.isFinite == false || actualPercent.isFinite == false {            return nil        }        let paceOnTop = actualUsed <= expectedUsed        let pacePercent: Double? = if detail.stage == .onTrack {            nil        } else {            expectedPercent        }        return PaceDetail(            leftLabel: detail.leftLabel,            rightLabel: detail.rightLabel,            pacePercent: pacePercent,            paceOnTop: paceOnTop)    }     static func standardWeeklyPace(input: Input, window: RateWindow) -> UsagePace? {

Lines 1–500 of 952. Load more