wehub-resource-sync
333 lines
11 KiB
Swift
333 lines
11 KiB
Swift
import Foundation
|
|
|
|
public struct CodexBarConfig: Codable, Sendable {
|
|
public static let currentVersion = 1
|
|
|
|
public var version: Int
|
|
public var providers: [ProviderConfig]
|
|
|
|
public init(version: Int = Self.currentVersion, providers: [ProviderConfig]) {
|
|
self.version = version
|
|
self.providers = providers
|
|
}
|
|
|
|
public static func makeDefault(
|
|
metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata) -> CodexBarConfig
|
|
{
|
|
let providers = UsageProvider.allCases.map { provider in
|
|
Self.defaultProviderConfig(
|
|
provider,
|
|
metadata: metadata,
|
|
alibabaTokenPlanRegion: .international)
|
|
}
|
|
return CodexBarConfig(version: Self.currentVersion, providers: providers)
|
|
}
|
|
|
|
/// Alphabetical provider ordering with enabled providers on top: enabled first, then disabled,
|
|
/// each group sorted case-insensitively by display name. Used by the Providers settings pane's
|
|
/// alphabetical sort toggle; it never mutates the user's stored manual order.
|
|
public static func alphabeticalProviderOrder(
|
|
metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata,
|
|
enablement: (UsageProvider) -> Bool) -> [UsageProvider]
|
|
{
|
|
UsageProvider.allCases.sorted { lhs, rhs in
|
|
let lhsEnabled = enablement(lhs)
|
|
let rhsEnabled = enablement(rhs)
|
|
if lhsEnabled != rhsEnabled { return lhsEnabled }
|
|
let lhsName = metadata[lhs]?.displayName ?? lhs.rawValue
|
|
let rhsName = metadata[rhs]?.displayName ?? rhs.rawValue
|
|
switch lhsName.localizedCaseInsensitiveCompare(rhsName) {
|
|
case .orderedAscending: return true
|
|
case .orderedDescending: return false
|
|
case .orderedSame: return lhs.rawValue < rhs.rawValue
|
|
}
|
|
}
|
|
}
|
|
|
|
public func normalized(
|
|
metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata) -> CodexBarConfig
|
|
{
|
|
var seen: Set<UsageProvider> = []
|
|
var normalized: [ProviderConfig] = []
|
|
normalized.reserveCapacity(max(self.providers.count, UsageProvider.allCases.count))
|
|
|
|
for provider in self.providers {
|
|
guard !seen.contains(provider.id) else { continue }
|
|
seen.insert(provider.id)
|
|
normalized.append(provider)
|
|
}
|
|
|
|
for provider in UsageProvider.allCases where !seen.contains(provider) {
|
|
normalized.append(Self.defaultProviderConfig(
|
|
provider,
|
|
metadata: metadata,
|
|
alibabaTokenPlanRegion: .chinaMainland))
|
|
}
|
|
|
|
return CodexBarConfig(
|
|
version: Self.currentVersion,
|
|
providers: normalized)
|
|
}
|
|
|
|
public func orderedProviders() -> [UsageProvider] {
|
|
self.providers.map(\.id)
|
|
}
|
|
|
|
public func enabledProviders(
|
|
metadata: [UsageProvider: ProviderMetadata] = ProviderDescriptorRegistry.metadata) -> [UsageProvider]
|
|
{
|
|
self.providers.compactMap { config in
|
|
let enabled = config.enabled ?? metadata[config.id]?.defaultEnabled ?? false
|
|
return enabled ? config.id : nil
|
|
}
|
|
}
|
|
|
|
public func providerConfig(for id: UsageProvider) -> ProviderConfig? {
|
|
self.providers.first(where: { $0.id == id })
|
|
}
|
|
|
|
public mutating func setProviderConfig(_ config: ProviderConfig) {
|
|
if let index = self.providers.firstIndex(where: { $0.id == config.id }) {
|
|
self.providers[index] = config
|
|
} else {
|
|
self.providers.append(config)
|
|
}
|
|
}
|
|
|
|
private static func defaultProviderConfig(
|
|
_ provider: UsageProvider,
|
|
metadata: [UsageProvider: ProviderMetadata],
|
|
alibabaTokenPlanRegion: AlibabaTokenPlanAPIRegion) -> ProviderConfig
|
|
{
|
|
ProviderConfig(
|
|
id: provider,
|
|
enabled: metadata[provider]?.defaultEnabled,
|
|
region: provider == .alibabatokenplan ? alibabaTokenPlanRegion.rawValue : nil)
|
|
}
|
|
}
|
|
|
|
public struct ProviderConfig: Codable, Sendable, Identifiable {
|
|
public let id: UsageProvider
|
|
public var enabled: Bool?
|
|
public var source: ProviderSourceMode?
|
|
public var extrasEnabled: Bool?
|
|
public var apiKey: String?
|
|
public var secretKey: String?
|
|
public var cookieHeader: String?
|
|
public var cookieSource: ProviderCookieSource?
|
|
public var region: String?
|
|
public var workspaceID: String?
|
|
public var enterpriseHost: String?
|
|
public var tokenAccounts: ProviderTokenAccountData?
|
|
public var claudeSwapEnabled: Bool?
|
|
public var claudeSwapExecutablePath: String?
|
|
public var codexActiveSource: CodexActiveSource?
|
|
public var codexProfileHomePaths: [String]?
|
|
public var quotaWarnings: QuotaWarningConfig?
|
|
public var kiloKnownOrganizations: [KiloOrganization]?
|
|
public var kiloEnabledOrganizationIDs: [String]?
|
|
public var awsProfile: String?
|
|
public var awsAuthMode: String?
|
|
|
|
public init(
|
|
id: UsageProvider,
|
|
enabled: Bool? = nil,
|
|
source: ProviderSourceMode? = nil,
|
|
extrasEnabled: Bool? = nil,
|
|
apiKey: String? = nil,
|
|
secretKey: String? = nil,
|
|
cookieHeader: String? = nil,
|
|
cookieSource: ProviderCookieSource? = nil,
|
|
region: String? = nil,
|
|
workspaceID: String? = nil,
|
|
enterpriseHost: String? = nil,
|
|
tokenAccounts: ProviderTokenAccountData? = nil,
|
|
claudeSwapEnabled: Bool? = nil,
|
|
claudeSwapExecutablePath: String? = nil,
|
|
codexActiveSource: CodexActiveSource? = nil,
|
|
codexProfileHomePaths: [String]? = nil,
|
|
quotaWarnings: QuotaWarningConfig? = nil,
|
|
kiloKnownOrganizations: [KiloOrganization]? = nil,
|
|
kiloEnabledOrganizationIDs: [String]? = nil,
|
|
awsProfile: String? = nil,
|
|
awsAuthMode: String? = nil)
|
|
{
|
|
self.id = id
|
|
self.enabled = enabled
|
|
self.source = source
|
|
self.extrasEnabled = extrasEnabled
|
|
self.apiKey = apiKey
|
|
self.secretKey = secretKey
|
|
self.cookieHeader = cookieHeader
|
|
self.cookieSource = cookieSource
|
|
self.region = region
|
|
self.workspaceID = workspaceID
|
|
self.enterpriseHost = enterpriseHost
|
|
self.tokenAccounts = tokenAccounts
|
|
self.claudeSwapEnabled = claudeSwapEnabled
|
|
self.claudeSwapExecutablePath = claudeSwapExecutablePath
|
|
self.codexActiveSource = codexActiveSource
|
|
self.codexProfileHomePaths = codexProfileHomePaths
|
|
self.quotaWarnings = quotaWarnings
|
|
self.kiloKnownOrganizations = kiloKnownOrganizations
|
|
self.kiloEnabledOrganizationIDs = kiloEnabledOrganizationIDs
|
|
self.awsProfile = awsProfile
|
|
self.awsAuthMode = awsAuthMode
|
|
}
|
|
|
|
public var sanitizedAPIKey: String? {
|
|
Self.clean(self.apiKey)
|
|
}
|
|
|
|
public var sanitizedSecretKey: String? {
|
|
Self.clean(self.secretKey)
|
|
}
|
|
|
|
public var sanitizedCookieHeader: String? {
|
|
Self.clean(self.cookieHeader)
|
|
}
|
|
|
|
public var sanitizedRegion: String? {
|
|
Self.clean(self.region)
|
|
}
|
|
|
|
public var sanitizedWorkspaceID: String? {
|
|
Self.clean(self.workspaceID)
|
|
}
|
|
|
|
public var sanitizedEnterpriseHost: String? {
|
|
Self.clean(self.enterpriseHost)
|
|
}
|
|
|
|
public var sanitizedClaudeSwapExecutablePath: String? {
|
|
Self.clean(self.claudeSwapExecutablePath)
|
|
}
|
|
|
|
public var sanitizedAWSProfile: String? {
|
|
Self.clean(self.awsProfile)
|
|
}
|
|
|
|
public var sanitizedAWSAuthMode: String? {
|
|
Self.clean(self.awsAuthMode)
|
|
}
|
|
|
|
private static func clean(_ raw: String?) -> String? {
|
|
guard var value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
|
|
return nil
|
|
}
|
|
if (value.hasPrefix("\"") && value.hasSuffix("\"")) ||
|
|
(value.hasPrefix("'") && value.hasSuffix("'"))
|
|
{
|
|
value = String(value.dropFirst().dropLast())
|
|
}
|
|
value = value.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return value.isEmpty ? nil : value
|
|
}
|
|
}
|
|
|
|
public enum QuotaWarningWindow: String, Codable, Sendable, CaseIterable {
|
|
case session
|
|
case weekly
|
|
|
|
public var displayName: String {
|
|
switch self {
|
|
case .session:
|
|
"session"
|
|
case .weekly:
|
|
"weekly"
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct QuotaWarningWindowConfig: Codable, Sendable, Equatable {
|
|
public var thresholds: [Int]?
|
|
public var enabled: Bool?
|
|
|
|
public init(thresholds: [Int]? = nil, enabled: Bool? = nil) {
|
|
self.thresholds = thresholds.map(QuotaWarningThresholds.sanitized)
|
|
self.enabled = enabled
|
|
}
|
|
|
|
public var hasOverride: Bool {
|
|
self.thresholds != nil || self.enabled != nil
|
|
}
|
|
|
|
public func isEnabled(global: Bool) -> Bool {
|
|
self.enabled ?? (self.thresholds != nil ? true : global)
|
|
}
|
|
}
|
|
|
|
public struct QuotaWarningConfig: Codable, Sendable, Equatable {
|
|
public var session: QuotaWarningWindowConfig?
|
|
public var weekly: QuotaWarningWindowConfig?
|
|
|
|
public init(
|
|
session: QuotaWarningWindowConfig? = nil,
|
|
weekly: QuotaWarningWindowConfig? = nil)
|
|
{
|
|
self.session = session
|
|
self.weekly = weekly
|
|
}
|
|
|
|
public func thresholds(for window: QuotaWarningWindow, global: [Int]) -> [Int] {
|
|
switch window {
|
|
case .session:
|
|
QuotaWarningThresholds.sanitized(self.session?.thresholds ?? global)
|
|
case .weekly:
|
|
QuotaWarningThresholds.sanitized(self.weekly?.thresholds ?? global)
|
|
}
|
|
}
|
|
|
|
public func isEnabled(for window: QuotaWarningWindow, global: Bool) -> Bool {
|
|
switch window {
|
|
case .session:
|
|
self.session?.isEnabled(global: global) ?? global
|
|
case .weekly:
|
|
self.weekly?.isEnabled(global: global) ?? global
|
|
}
|
|
}
|
|
|
|
public func hasOverride(for window: QuotaWarningWindow) -> Bool {
|
|
switch window {
|
|
case .session:
|
|
self.session?.hasOverride ?? false
|
|
case .weekly:
|
|
self.weekly?.hasOverride ?? false
|
|
}
|
|
}
|
|
|
|
public var isEmpty: Bool {
|
|
self.session?.hasOverride != true && self.weekly?.hasOverride != true
|
|
}
|
|
}
|
|
|
|
public enum QuotaWarningThresholds {
|
|
public static let defaults = [50, 20]
|
|
public static let allowedRange = 0...99
|
|
|
|
public static func sanitized(_ raw: [Int]) -> [Int] {
|
|
guard !raw.isEmpty else { return self.defaults }
|
|
|
|
let unique = Set(raw.map(self.clamped))
|
|
let sorted = unique.sorted(by: >)
|
|
return sorted.isEmpty ? self.defaults : sorted
|
|
}
|
|
|
|
public static func active(_ raw: [Int]) -> [Int] {
|
|
self.sanitized(raw).filter { $0 > 0 }
|
|
}
|
|
|
|
public static func resolved(upper: Int?, lower: Int?) -> [Int] {
|
|
guard upper != nil || lower != nil else { return self.defaults }
|
|
|
|
let resolvedUpper = self.clamped(upper ?? self.defaults[0])
|
|
let lowerDefault = resolvedUpper < self.defaults[1] ? 0 : self.defaults[1]
|
|
let resolvedLower = self.clamped(lower ?? lowerDefault)
|
|
return self.sanitized([resolvedUpper, resolvedLower])
|
|
}
|
|
|
|
public static func clamped(_ value: Int) -> Int {
|
|
min(max(value, self.allowedRange.lowerBound), self.allowedRange.upperBound)
|
|
}
|
|
}
|