feat: add LongCat usage provider

Cookie-based web provider for LongCat (Meituan) that surfaces console
token quota (总额度) and fuel-pack balance (加油包) by reading the
longcat.chat platform session, mirroring the Kimi/MiniMax cookie pattern.

Field mapping is locked against captured live responses:
- GET /api/v1/user-current        -> data.name
- GET /api/lc-platform/v1/tokenUsage          -> data.usage.{total,used,available}Token
- GET /api/lc-platform/v1/pending-fuel-packages -> data.totalQuota + data.list[]

The public API key path exposes no usage endpoint, so usage is read from
the web console session (all longcat.chat cookies are forwarded since the
Meituan passport cookie name is undocumented). The user-current body is
never logged (it carries a session token + phone).

Wires .longcat into the provider/icon enums, descriptor registry, settings
snapshot/builder, implementation registry, logging, widget, cost-usage and
debug switches; adds brand icon, docs provider-id list, CHANGELOG entry and
unit tests covering the live response shapes.

Author: LeoLin990405

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## Unreleased
+
+### Added
+- LongCat: show console quota (总额度), fuel-pack balance (加油包), and today's token usage from a browser session. Thanks @LeoLin990405!
+
 ## 0.37.1 — 2026-06-21
 
 ### Fixed

Sources/CodexBar/Providers/LongCat/LongCatProviderImplementation.swift

@@ -0,0 +1,100 @@
+import AppKit
+import CodexBarCore
+import Foundation
+import SwiftUI
+
+struct LongCatProviderImplementation: ProviderImplementation {
+    let id: UsageProvider = .longcat
+
+    @MainActor
+    func presentation(context _: ProviderPresentationContext) -> ProviderPresentation {
+        ProviderPresentation { context in
+            context.store.sourceLabel(for: context.provider)
+        }
+    }
+
+    @MainActor
+    func observeSettings(_ settings: SettingsStore) {
+        _ = settings.longcatUsageDataSource
+        _ = settings.longcatCookieSource
+        _ = settings.longcatManualCookieHeader
+    }
+
+    @MainActor
+    func settingsSnapshot(context: ProviderSettingsSnapshotContext) -> ProviderSettingsSnapshotContribution? {
+        .longcat(context.settings.longcatSettingsSnapshot(tokenOverride: context.tokenOverride))
+    }
+
+    @MainActor
+    func defaultSourceLabel(context: ProviderSourceLabelContext) -> String? {
+        context.settings.longcatUsageDataSource.rawValue
+    }
+
+    @MainActor
+    func sourceMode(context: ProviderSourceModeContext) -> ProviderSourceMode {
+        switch context.settings.longcatUsageDataSource {
+        case .web: .web
+        case .auto, .api, .cli, .oauth: .auto
+        }
+    }
+
+    @MainActor
+    func settingsPickers(context: ProviderSettingsContext) -> [ProviderSettingsPickerDescriptor] {
+        let cookieBinding = Binding(
+            get: { context.settings.longcatCookieSource.rawValue },
+            set: { raw in
+                context.settings.longcatCookieSource = ProviderCookieSource(rawValue: raw) ?? .auto
+            })
+        let options = ProviderCookieSourceUI.options(
+            allowsOff: true,
+            keychainDisabled: context.settings.debugDisableKeychainAccess)
+
+        let subtitle: () -> String? = {
+            ProviderCookieSourceUI.subtitle(
+                source: context.settings.longcatCookieSource,
+                keychainDisabled: context.settings.debugDisableKeychainAccess,
+                auto: "Automatic imports longcat.chat cookies from your browser.",
+                manual: "Paste a Cookie header copied from longcat.chat.",
+                off: "LongCat cookies are disabled.")
+        }
+
+        return [
+            ProviderSettingsPickerDescriptor(
+                id: "longcat-cookie-source",
+                title: "Cookie source",
+                subtitle: "Automatic imports longcat.chat cookies from your browser.",
+                dynamicSubtitle: subtitle,
+                binding: cookieBinding,
+                options: options,
+                isVisible: nil,
+                onChange: nil),
+        ]
+    }
+
+    @MainActor
+    func settingsFields(context: ProviderSettingsContext) -> [ProviderSettingsFieldDescriptor] {
+        [
+            ProviderSettingsFieldDescriptor(
+                id: "longcat-cookie",
+                title: "",
+                subtitle: "",
+                kind: .secure,
+                placeholder: "Cookie: \u{2026}",
+                binding: context.stringBinding(\.longcatManualCookieHeader),
+                actions: [
+                    ProviderSettingsActionDescriptor(
+                        id: "longcat-open-console",
+                        title: "Open Console",
+                        style: .link,
+                        isVisible: nil,
+                        perform: {
+                            if let url = URL(string: "https://longcat.chat/platform/") {
+                                NSWorkspace.shared.open(url)
+                            }
+                        }),
+                ],
+                isVisible: { context.settings.longcatCookieSource == .manual },
+                onActivate: { context.settings.ensureLongCatCookieLoaded() }),
+        ]
+    }
+}

Sources/CodexBar/Providers/LongCat/LongCatSettingsStore.swift

@@ -0,0 +1,54 @@
+import CodexBarCore
+import Foundation
+
+extension SettingsStore {
+    var longcatUsageDataSource: ProviderSourceMode {
+        get { self.configSnapshot.providerConfig(for: .longcat)?.source ?? .auto }
+        set {
+            let source: ProviderSourceMode? = switch newValue {
+            case .auto: .auto
+            case .web: .web
+            case .api, .cli, .oauth: .auto
+            }
+            self.updateProviderConfig(provider: .longcat) { entry in
+                entry.source = source
+            }
+            self.logProviderModeChange(provider: .longcat, field: "usageSource", value: newValue.rawValue)
+        }
+    }
+
+    var longcatManualCookieHeader: String {
+        get { self.configSnapshot.providerConfig(for: .longcat)?.sanitizedCookieHeader ?? "" }
+        set {
+            self.updateProviderConfig(provider: .longcat) { entry in
+                entry.cookieHeader = self.normalizedConfigValue(newValue)
+            }
+            self.logSecretUpdate(provider: .longcat, field: "cookieHeader", value: newValue)
+        }
+    }
+
+    var longcatCookieSource: ProviderCookieSource {
+        get { self.resolvedCookieSource(provider: .longcat, fallback: .auto) }
+        set {
+            self.updateProviderConfig(provider: .longcat) { entry in
+                entry.cookieSource = newValue
+            }
+            self.logProviderModeChange(provider: .longcat, field: "cookieSource", value: newValue.rawValue)
+        }
+    }
+
+    func ensureLongCatCookieLoaded() {}
+}
+
+extension SettingsStore {
+    func longcatSettingsSnapshot(tokenOverride: TokenAccountOverride?)
+        -> ProviderSettingsSnapshot.LongCatProviderSettings
+    {
+        self.ensureLongCatCookieLoaded()
+        return self.resolvedCookieSettings(
+            provider: .longcat,
+            configuredSource: self.longcatCookieSource,
+            configuredHeader: self.longcatManualCookieHeader,
+            tokenOverride: tokenOverride)
+    }
+}

Sources/CodexBar/Providers/Shared/ProviderImplementationRegistry.swift

@@ -66,6 +66,7 @@ enum ProviderImplementationRegistry {
         case .deepgram: DeepgramProviderImplementation()
         case .poe: PoeProviderImplementation()
         case .chutes: ChutesProviderImplementation()
+        case .longcat: LongCatProviderImplementation()
         }
     }
 

Sources/CodexBar/Resources/ProviderIcon-longcat.svg

@@ -1086,7 +1086,7 @@ extension UsageStore {
                 case .gemini, .antigravity, .opencode, .opencodego, .alibabatokenplan, .factory, .copilot, .devin,
                      .vertexai, .kilo, .kiro, .kimi, .kimik2, .moonshot, .jetbrains, .perplexity, .mimo, .doubao,
                      .abacus, .mistral, .codebuff, .crof, .windsurf, .venice, .manus, .commandcode, .stepfun, .bedrock,
-                     .grok, .groq, .t3chat, .llmproxy, .litellm, .zed, .deepgram, .poe, .chutes:
+                     .grok, .groq, .t3chat, .llmproxy, .litellm, .zed, .deepgram, .poe, .chutes, .longcat:
                     return unimplementedDebugLogMessages[provider] ?? "Debug log not yet implemented"
                 }
             }

Sources/CodexBar/UsageStore.swift

@@ -1,5 +1,5 @@
 // Generated by Scripts/regenerate-codex-parser-hash.sh. Do not edit by hand.
 
 enum CodexParserHash {
-    static let value = "800a06dead603ea7"
+    static let value = "910b475f0fded3e5"
 }

Sources/CodexBarCore/Generated/CodexParserHash.generated.swift

@@ -42,6 +42,9 @@ public enum LogCategories {
     public static let kimiTokenStore = "kimi-token-store"
     public static let kimiWeb = "kimi-web"
     public static let kiro = "kiro"
+    public static let longcatAPI = "longcat-api"
+    public static let longcatCookie = "longcat-cookie"
+    public static let longcatWeb = "longcat-web"
     public static let launchAtLogin = "launch-at-login"
     public static let login = "login"
     public static let logging = "logging"

Sources/CodexBarCore/Logging/LogCategories.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+public enum LongCatAPIError: LocalizedError, Sendable, Equatable {
+    case missingCookies
+    case invalidSession
+    case invalidRequest(String)
+    case networkError(String)
+    case apiError(String)
+    case parseFailed(String)
+
+    public var errorDescription: String? {
+        switch self {
+        case .missingCookies:
+            "LongCat session cookies are missing. Sign in at longcat.chat, or paste a cookie header."
+        case .invalidSession:
+            "LongCat session is invalid or expired. Please sign in again at longcat.chat."
+        case let .invalidRequest(message):
+            "Invalid request: \(message)"
+        case let .networkError(message):
+            "LongCat network error: \(message)"
+        case let .apiError(message):
+            "LongCat API error: \(message)"
+        case let .parseFailed(message):
+            "Failed to parse LongCat usage data: \(message)"
+        }
+    }
+}

Sources/CodexBarCore/Providers/LongCat/LongCatAPIError.swift

@@ -0,0 +1,68 @@
+import Foundation
+
+public struct LongCatCookieOverride: Sendable {
+    /// Full `Cookie:` header value (e.g. `name=value; name2=value2`).
+    public let cookieHeader: String
+
+    public init(cookieHeader: String) {
+        self.cookieHeader = cookieHeader
+    }
+}
+
+public enum LongCatCookieHeader {
+    private static let log = CodexBarLog.logger(LogCategories.longcatCookie)
+    private static let headerPatterns: [String] = [
+        #"(?i)-H\s*'Cookie:\s*([^']+)'"#,
+        #"(?i)-H\s*"Cookie:\s*([^"]+)""#,
+        #"(?i)\bcookie:\s*'([^']+)'"#,
+        #"(?i)\bcookie:\s*"([^"]+)""#,
+        #"(?i)\bcookie:\s*([^\r\n]+)"#,
+    ]
+
+    public static func resolveCookieOverride(context: ProviderFetchContext) -> LongCatCookieOverride? {
+        if let settings = context.settings?.longcat, settings.cookieSource == .manual {
+            if let manual = settings.manualCookieHeader, !manual.isEmpty {
+                return self.override(from: manual)
+            }
+        }
+
+        if let envHeader = self.override(from: context.env["LONGCAT_MANUAL_COOKIE"]) {
+            return envHeader
+        }
+
+        return nil
+    }
+
+    public static func override(from raw: String?) -> LongCatCookieOverride? {
+        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else {
+            return nil
+        }
+
+        if let header = self.extractHeader(from: raw) {
+            return LongCatCookieOverride(cookieHeader: header)
+        }
+
+        // A bare `name=value; ...` string is itself a usable cookie header.
+        if raw.contains("=") {
+            return LongCatCookieOverride(cookieHeader: raw)
+        }
+
+        return nil
+    }
+
+    private static func extractHeader(from raw: String) -> String? {
+        for pattern in self.headerPatterns {
+            guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { continue }
+            let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
+            guard let match = regex.firstMatch(in: raw, options: [], range: range),
+                  match.numberOfRanges >= 2,
+                  let captureRange = Range(match.range(at: 1), in: raw)
+            else {
+                continue
+            }
+            let captured = String(raw[captureRange]).trimmingCharacters(in: .whitespacesAndNewlines)
+            if !captured.isEmpty { return captured }
+        }
+        return nil
+    }
+}