MiniMax: recharge credits, usage dashboard, and quota utilization

CHANGELOG.md

@@ -5,6 +5,8 @@
 ### Added
 - Menu: add an opt-in setting to refresh provider usage whenever the menu opens without changing the periodic refresh clock. Thanks @dstier-git!
 - Quota warnings: add an optional centered on-screen text alert that stays click-through and does not steal focus. Thanks @SAASEmpiree!
+- MiniMax: fetch Token Plan recharge-credit balance from the console `token_plan_credit` endpoint when a browser session cookie is available. Thanks @Yuxin-Qiao!
+- MiniMax: persist detected China API region after a successful global-to-CN token retry so later refreshes skip the extra probe.
 
 ### Fixed
 - Claude web usage: bound stale requests so Auto can reach CLI fallback instead of hanging indefinitely.

Sources/CodexBar/ProviderRegistry.swift

@@ -81,6 +81,15 @@ struct ProviderRegistry {
                                 }
                             }
                         },
+                        providerRegionUpdater: { provider, region in
+                            await MainActor.run {
+                                guard provider == .minimax,
+                                      let resolved = MiniMaxAPIRegion(rawValue: region),
+                                      settings.minimaxAPIRegion != resolved
+                                else { return }
+                                settings.minimaxAPIRegion = resolved
+                            }
+                        },
                         costUsageHistoryDays: settings.costUsageHistoryDays,
                         persistsCLISessions: true,
                         persistentCLISessionIdleWindow: Self.persistentCLISessionIdleWindow(

Sources/CodexBar/UsageStore+TokenAccounts.swift

@@ -711,6 +711,16 @@ extension UsageStore {
                     self.settings.stepfunToken = token
                 }
             },
+            providerRegionUpdater: { [weak self] provider, region in
+                await MainActor.run {
+                    guard let self,
+                          provider == .minimax,
+                          let resolved = MiniMaxAPIRegion(rawValue: region),
+                          self.settings.minimaxAPIRegion != resolved
+                    else { return }
+                    self.settings.minimaxAPIRegion = resolved
+                }
+            },
             costUsageHistoryDays: self.settings.costUsageHistoryDays,
             persistsCLISessions: true,
             persistentCLISessionIdleWindow: ProviderRegistry.persistentCLISessionIdleWindow(

Sources/CodexBarCLI/CLIDiagnoseCommand.swift

@@ -140,7 +140,8 @@ extension CodexBarCLI {
             browserDetection: browserDetection,
             selectedTokenAccountID: account?.id,
             tokenAccountTokenUpdater: tokenContext.tokenUpdater(for: account),
-            providerManualTokenUpdater: tokenContext.manualTokenUpdater())
+            providerManualTokenUpdater: tokenContext.manualTokenUpdater(),
+            providerRegionUpdater: tokenContext.regionUpdater())
         let descriptor = ProviderDescriptorRegistry.descriptor(for: provider)
         let outcome = await Self.fetchProviderUsage(provider: provider, context: fetchContext)
         return ProviderDiagnosticExportBuilder.build(.init(

Sources/CodexBarCLI/CLIUsageCommand.swift

@@ -340,6 +340,7 @@ extension CodexBarCLI {
             selectedTokenAccountID: account?.id,
             tokenAccountTokenUpdater: tokenContext.tokenUpdater(for: account),
             providerManualTokenUpdater: tokenContext.manualTokenUpdater(),
+            providerRegionUpdater: tokenContext.regionUpdater(),
             persistsCLISessions: Self.persistsCLISessions(provider: provider, command: command),
             persistentCLISessionIdleWindow: command.persistentCLISessionIdleWindow)
         let outcome = await Self.fetchProviderUsage(provider: provider, context: fetchContext)

Sources/CodexBarCLI/TokenAccountCLI.swift

@@ -324,6 +324,26 @@ struct TokenAccountCLIContext {
         }
     }
 
+    func regionUpdater() -> ProviderFetchContext.ProviderRegionUpdater {
+        { provider, region in
+            try? Self.updateStoredRegion(provider: provider, region: region)
+        }
+    }
+
+    private static func updateStoredRegion(provider: UsageProvider, region: String) throws {
+        guard provider == .minimax else { return }
+        let trimmed = region.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return }
+
+        let store = CodexBarConfigStore()
+        var config = try store.load() ?? .makeDefault()
+        var providerConfig = config.providerConfig(for: provider) ?? ProviderConfig(id: provider)
+        guard providerConfig.region != trimmed else { return }
+        providerConfig.region = trimmed
+        config.setProviderConfig(providerConfig)
+        try store.save(config)
+    }
+
     private static func updateStoredManualToken(provider: UsageProvider, token: String) throws {
         guard provider == .stepfun else { return }
         let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)

Sources/CodexBarCore/Providers/MiniMax/MiniMaxAPIRegion.swift

@@ -8,6 +8,7 @@ public enum MiniMaxAPIRegion: String, CaseIterable, Sendable {
     private static let codingPlanQuery = "cycle_type=3"
     private static let remainsPath = "v1/api/openplatform/coding_plan/remains"
     private static let tokenPlanRemainsPath = "v1/token_plan/remains"
+    private static let tokenPlanCreditPath = "backend/account/token_plan_credit"
     private static let billingHistoryPath = "account/amount"
 
     public var displayName: String {
@@ -37,6 +38,19 @@ public enum MiniMaxAPIRegion: String, CaseIterable, Sendable {
         }
     }
 
+    public var webBaseURLString: String {
+        switch self {
+        case .global:
+            "https://www.minimax.io"
+        case .chinaMainland:
+            "https://www.minimaxi.com"
+        }
+    }
+
+    public var tokenPlanCreditURL: URL {
+        URL(string: self.webBaseURLString)!.appendingPathComponent(Self.tokenPlanCreditPath)
+    }
+
     public var codingPlanURL: URL {
         var components = URLComponents(string: self.baseURLString)!
         components.path = "/" + Self.codingPlanPath

Sources/CodexBarCore/Providers/MiniMax/MiniMaxProviderDescriptor.swift

@@ -85,13 +85,43 @@ struct MiniMaxAPIFetchStrategy: ProviderFetchStrategy {
         guard let apiToken = ProviderTokenResolver.minimaxToken(environment: context.env) else {
             throw MiniMaxAPISettingsError.missingToken
         }
-        let region = context.settings?.minimax?.apiRegion ?? .global
-        let usage = try await MiniMaxUsageFetcher.fetchUsage(apiToken: apiToken, region: region)
+        let preferredRegion = context.settings?.minimax?.apiRegion ?? .global
+        let apiResult = try await MiniMaxUsageFetcher.fetchAPITokenUsage(
+            apiToken: apiToken,
+            region: preferredRegion)
+        if apiResult.resolvedRegion != preferredRegion {
+            await context.providerRegionUpdater?(.minimax, apiResult.resolvedRegion.rawValue)
+        }
+        var usage = apiResult.snapshot
+        if let cookieOverride = Self.resolveExplicitCookieOverride(context: context),
+           let cookie = MiniMaxCookieHeader.normalized(from: cookieOverride.cookieHeader)
+        {
+            let fetchContext = MiniMaxUsageFetcher.WebFetchContext(
+                cookie: cookie,
+                authorizationToken: cookieOverride.authorizationToken,
+                region: apiResult.resolvedRegion,
+                environment: context.env,
+                transport: ProviderHTTPClient.shared)
+            usage = try await MiniMaxUsageFetcher.attachingTokenPlanCreditIfAvailable(
+                to: usage,
+                context: fetchContext,
+                groupID: cookieOverride.groupID)
+        }
         return self.makeResult(
             usage: usage.toUsageSnapshot(),
             sourceLabel: "api")
     }
 
+    private static func resolveExplicitCookieOverride(context: ProviderFetchContext) -> MiniMaxCookieOverride? {
+        if let settings = context.settings?.minimax, settings.cookieSource == .manual {
+            return MiniMaxCookieHeader.override(from: settings.manualCookieHeader)
+        }
+        guard let raw = ProviderTokenResolver.minimaxCookie(environment: context.env) else {
+            return nil
+        }
+        return MiniMaxCookieHeader.override(from: raw)
+    }
+
     func shouldFallback(on error: Error, context _: ProviderFetchContext) -> Bool {
         guard let minimaxError = error as? MiniMaxUsageError else { return false }
         switch minimaxError {

Sources/CodexBarCore/Providers/MiniMax/MiniMaxSettingsReader.swift

@@ -11,12 +11,14 @@ public struct MiniMaxSettingsReader: Sendable {
     public static let hostKey = "MINIMAX_HOST"
     public static let codingPlanURLKey = "MINIMAX_CODING_PLAN_URL"
     public static let remainsURLKey = "MINIMAX_REMAINS_URL"
+    public static let tokenPlanCreditURLKey = "MINIMAX_TOKEN_PLAN_CREDIT_URL"
     public static let billingHistoryURLKey = "MINIMAX_BILLING_HISTORY_URL"
     public static let requireProviderEndpointOverridesKey = "MINIMAX_REQUIRE_PROVIDER_ENDPOINT_OVERRIDES"
     private static let endpointOverrideKeys = [
         Self.hostKey,
         Self.codingPlanURLKey,
         Self.remainsURLKey,
+        Self.tokenPlanCreditURLKey,
         Self.billingHistoryURLKey,
     ]
 
@@ -71,6 +73,14 @@ public struct MiniMaxSettingsReader: Sendable {
             policy: self.endpointOverrideHostPolicy(environment: environment))
     }
 
+    public static func tokenPlanCreditURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
+    {
+        self.endpointValidator.validatedURL(
+            self.cleaned(environment[self.tokenPlanCreditURLKey]),
+            policy: self.endpointOverrideHostPolicy(environment: environment))
+    }
+
     public static func billingHistoryURL(
         environment: [String: String] = ProcessInfo.processInfo.environment) -> URL?
     {

Sources/CodexBarCore/Providers/MiniMax/MiniMaxSubscriptionMetadata.swift

@@ -271,4 +271,34 @@ extension MiniMaxUsageFetcher {
             return snapshot
         }
     }
+
+    static func attachingTokenPlanCreditIfAvailable(
+        to snapshot: MiniMaxUsageSnapshot,
+        context: WebFetchContext,
+        groupID: String?) async throws -> MiniMaxUsageSnapshot
+    {
+        guard snapshot.pointsBalance == nil,
+              MiniMaxCookieHeader.normalized(from: context.cookie) != nil
+        else {
+            return snapshot
+        }
+
+        let resolvedGroupID = groupID ?? MiniMaxCookieHeader.override(from: context.cookie)?.groupID
+        do {
+            let balance = try await MiniMaxTokenPlanCreditFetcher.fetch(
+                cookieHeader: context.cookie,
+                groupID: resolvedGroupID,
+                region: context.region,
+                environment: context.environment,
+                transport: context.transport)
+            return snapshot.withPointsBalanceIfMissing(balance)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let error as URLError where error.code == .cancelled {
+            throw CancellationError()
+        } catch {
+            Self.log.debug("MiniMax token plan credit unavailable: \(error.localizedDescription)")
+            return snapshot
+        }
+    }
 }

Sources/CodexBarCore/Providers/MiniMax/MiniMaxTokenPlanCreditFetcher.swift

@@ -0,0 +1,120 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+enum MiniMaxTokenPlanCreditFetcher {
+    static func fetch(
+        cookieHeader: String,
+        groupID: String?,
+        region: MiniMaxAPIRegion,
+        environment: [String: String],
+        transport: any ProviderHTTPTransport) async throws -> Double?
+    {
+        let url = try self.resolveCreditURL(region: region, environment: environment)
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
+        if let groupID = groupID?.trimmingCharacters(in: .whitespacesAndNewlines), !groupID.isEmpty {
+            request.setValue(groupID, forHTTPHeaderField: "x-group-id")
+        }
+        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "accept")
+        request.setValue("XMLHttpRequest", forHTTPHeaderField: "x-requested-with")
+        let userAgent =
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
+            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+        request.setValue(userAgent, forHTTPHeaderField: "user-agent")
+        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "accept-language")
+        let origin = MiniMaxSubscriptionMetadataFetcher.platformOriginURL(region: region)
+        request.setValue(origin.absoluteString, forHTTPHeaderField: "origin")
+        request.setValue(origin.absoluteString + "/", forHTTPHeaderField: "referer")
+
+        let response = try await transport.response(for: request)
+        guard response.statusCode == 200 else {
+            if response.statusCode == 401 || response.statusCode == 403 {
+                throw MiniMaxUsageError.invalidCredentials
+            }
+            throw MiniMaxUsageError.apiError("HTTP \(response.statusCode)")
+        }
+        return try self.parseBalance(data: response.data)
+    }
+
+    static func parseBalance(data: Data) throws -> Double? {
+        let object = try JSONSerialization.jsonObject(with: data, options: [])
+        guard let payload = object as? [String: Any] else {
+            throw MiniMaxUsageError.parseFailed("MiniMax token plan credit payload was not an object.")
+        }
+        try self.validateBaseResponse(in: payload)
+        return self.balance(from: payload)
+    }
+
+    static func resolveCreditURL(region: MiniMaxAPIRegion, environment: [String: String]) throws -> URL {
+        if let rejectedKey = MiniMaxSettingsReader.rejectedEndpointOverrideKey(environment: environment) {
+            throw ProviderEndpointOverrideError.minimax(rejectedKey)
+        }
+        if let override = MiniMaxSettingsReader.tokenPlanCreditURL(environment: environment) {
+            return override
+        }
+        return region.tokenPlanCreditURL
+    }
+
+    private static func validateBaseResponse(in payload: [String: Any]) throws {
+        guard let baseResp = payload["base_resp"] as? [String: Any] else { return }
+        let status = self.intValue(baseResp["status_code"]) ?? 0
+        guard status != 0 else { return }
+        let message = (baseResp["status_msg"] as? String) ?? "MiniMax token plan credit error \(status)"
+        if status == 1004 || message.lowercased().contains("cookie") || message.lowercased().contains("login") {
+            throw MiniMaxUsageError.invalidCredentials
+        }
+        throw MiniMaxUsageError.apiError(message)
+    }
+
+    private static func balance(from payload: [String: Any]) -> Double? {
+        if let balance = self.doubleValue(payload["remaining_credits"]), balance >= 0 {
+            return balance
+        }
+        if let breakdown = payload["balance_breakdown"] as? [String: Any],
+           let balance = self.doubleValue(breakdown["total_balance"]),
+           balance >= 0
+        {
+            return balance
+        }
+        if let balance = self.doubleValue(payload["points_balance"]), balance >= 0 {
+            return balance
+        }
+        if let balance = self.doubleValue(payload["total_credits"]),
+           let used = self.doubleValue(payload["used_credits"]),
+           balance >= used
+        {
+            return balance - used
+        }
+        return nil
+    }
+
+    private static func doubleValue(_ value: Any?) -> Double? {
+        if let number = value as? Double { return number }
+        if let number = value as? Int { return Double(number) }
+        if let string = value as? String {
+            return Double(string.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+        return nil
+    }
+
+    private static func intValue(_ value: Any?) -> Int? {
+        if let number = value as? Int { return number }
+        if let number = value as? Double { return Int(number) }
+        if let string = value as? String {
+            return Int(string.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+        return nil
+    }
+}
+
+extension MiniMaxSubscriptionMetadataFetcher {
+    static func platformOriginURL(region: MiniMaxAPIRegion) -> URL {
+        switch region {
+        case .global: URL(string: "https://platform.minimax.io")!
+        case .chinaMainland: URL(string: "https://platform.minimaxi.com")!
+        }
+    }
+}