mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-11-22 04:54:34 +00:00
* fix(clinepass): say when the Cline login expired and how to renew it An expired saved Cline login only said "Run cline to refresh it". It now reads "Cline login expired 3h ago" (age from the saved expiry, when known) and asks to send a message in Cline or run `cline auth cline`, then press Retry. Still a retryable state, so the last quota is kept. CLI and menubar. * fix(menubar): title an expired Cline login instead of "Retrying" A provider failure can now carry a short status title. The expired Cline login sets "Cline login expired", which the settings pane and the dock caption show in place of the generic retrying text. It stays a retryable state and keeps the last quota; the title clears with the error. * fix(clinepass): match the expired-login hint to the visible control "Then press Retry" only fits where a Retry button shows: the settings pane with no last quota. Everywhere else, including the CLI, the hint now ends with "CodeBurn picks up the new login on its next refresh."
269 lines
10 KiB
Swift
269 lines
10 KiB
Swift
import Foundation
|
|
|
|
/// Marks the refresh as an explicit user action without granting hidden access
|
|
/// to browser cookies, another app's Keychain items, or copied provider code.
|
|
@MainActor
|
|
enum CapacityDockProviderRefreshInteraction {
|
|
static func userInitiated<T>(
|
|
operation: () async throws -> T
|
|
) async rethrows -> T {
|
|
try await operation()
|
|
}
|
|
}
|
|
|
|
/// CodeBurn-owned registry for Capacity Dock providers that are not served by
|
|
/// AppStore's six native quota paths. A provider is connectable only when an
|
|
/// adapter is explicitly registered here.
|
|
@MainActor
|
|
final class CapacityDockProviderQuotaService {
|
|
struct Dependencies: Sendable {
|
|
// No defaults here: only `.live` may reach the real adapters, so a
|
|
// test can never silently read the local Cursor session or hit the
|
|
// network by omitting a field.
|
|
var refreshClinePass: @Sendable (String?) async throws -> QuotaSummary
|
|
var refreshCommandCode: @Sendable () async throws -> QuotaSummary
|
|
var refreshCursor: @Sendable () async throws -> QuotaSummary
|
|
var refreshDevin: @Sendable () async throws -> QuotaSummary
|
|
var refreshGrok: @Sendable () async throws -> QuotaSummary
|
|
var refreshGrokBot: @Sendable () async throws -> QuotaSummary
|
|
var refreshZai: @Sendable (String?) async throws -> QuotaSummary
|
|
var refreshZcode: @Sendable () async throws -> QuotaSummary
|
|
|
|
static let live = Dependencies(
|
|
refreshClinePass: { apiKey in
|
|
try await ClinePassSubscriptionService.refresh(apiKey: apiKey)
|
|
},
|
|
refreshCommandCode: {
|
|
try await CommandCodeSubscriptionService.refresh()
|
|
},
|
|
refreshCursor: {
|
|
try await CursorSubscriptionService.refresh()
|
|
},
|
|
refreshDevin: {
|
|
try DevinSubscriptionService.refresh()
|
|
},
|
|
refreshGrok: {
|
|
try await GrokBuildSubscriptionService.refresh()
|
|
},
|
|
refreshGrokBot: {
|
|
try await GrokBotSubscriptionService.refresh()
|
|
},
|
|
refreshZai: { apiKey in
|
|
try await ZaiSubscriptionService.refresh(apiKey: apiKey)
|
|
},
|
|
refreshZcode: {
|
|
try await ZcodeSubscriptionService.refresh()
|
|
}
|
|
)
|
|
}
|
|
|
|
static let shared = CapacityDockProviderQuotaService(dependencies: .live)
|
|
|
|
private let dependencies: Dependencies
|
|
|
|
init(dependencies: Dependencies) {
|
|
self.dependencies = dependencies
|
|
}
|
|
|
|
func fetch(
|
|
provider: CapacityDockProvider,
|
|
credential: CapacityDockProviderCredential
|
|
) async throws -> QuotaSummary {
|
|
switch provider.id {
|
|
case "cursor":
|
|
do {
|
|
return try await dependencies.refreshCursor()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "devin":
|
|
do {
|
|
return try await dependencies.refreshDevin()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "grok":
|
|
do {
|
|
return try await dependencies.refreshGrok()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "grokbot":
|
|
do {
|
|
return try await dependencies.refreshGrokBot()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "clinepass":
|
|
do {
|
|
return try await dependencies.refreshClinePass(credential.sanitizedOverride.apiKey)
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "commandcode":
|
|
do {
|
|
return try await dependencies.refreshCommandCode()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "zai":
|
|
do {
|
|
return try await dependencies.refreshZai(credential.sanitizedOverride.apiKey)
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
case "zcode":
|
|
do {
|
|
return try await dependencies.refreshZcode()
|
|
} catch is CancellationError {
|
|
throw CancellationError()
|
|
} catch {
|
|
throw CapacityDockProviderFetchFailure(error: error)
|
|
}
|
|
default:
|
|
throw CapacityDockProviderFetchFailure(
|
|
message: "\(provider.displayName) does not have a CodeBurn live quota adapter yet. "
|
|
+ "Remove it from the dock or choose a supported provider.",
|
|
disposition: .terminal
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
enum CapacityDockProviderFetchFailureDisposition: Equatable, Sendable {
|
|
case terminal
|
|
case transient
|
|
}
|
|
|
|
/// The only failure distinction the dock needs: user-actionable connection
|
|
/// failures versus failures that should preserve last-known quota and retry.
|
|
struct CapacityDockProviderFetchFailure: LocalizedError, Equatable, Sendable {
|
|
let message: String
|
|
let disposition: CapacityDockProviderFetchFailureDisposition
|
|
/// A short status shown instead of the generic one for this failure.
|
|
var statusTitle: String?
|
|
/// The message variant for when a Retry button is on screen.
|
|
var retryMessage: String?
|
|
|
|
init(message: String, disposition: CapacityDockProviderFetchFailureDisposition) {
|
|
self.message = message
|
|
self.disposition = disposition
|
|
}
|
|
|
|
init(error: Error) {
|
|
switch error {
|
|
case ClinePassSubscriptionService.FetchError.noCredentials,
|
|
CommandCodeSubscriptionService.FetchError.noCredentials,
|
|
CursorSubscriptionService.FetchError.noCredentials,
|
|
DevinSubscriptionService.FetchError.noCache,
|
|
GrokBuildSubscriptionService.FetchError.noCredentials,
|
|
GrokBotSubscriptionService.FetchError.noCredentials,
|
|
GrokBotSubscriptionService.FetchError.notInstalled,
|
|
ZaiSubscriptionService.FetchError.noCredentials,
|
|
ZcodeSubscriptionService.FetchError.noCredentials:
|
|
notSignedIn = true
|
|
default:
|
|
break
|
|
}
|
|
message = error.localizedDescription
|
|
disposition = Self.disposition(for: error)
|
|
statusTitle = (error as? ClinePassSubscriptionService.FetchError)?.statusTitle
|
|
retryMessage = (error as? ClinePassSubscriptionService.FetchError)?.retryMessage
|
|
}
|
|
|
|
var errorDescription: String? { message }
|
|
|
|
/// No credentials or local app data at all, as opposed to a failed check.
|
|
var notSignedIn = false
|
|
|
|
static func disposition(for error: Error) -> CapacityDockProviderFetchFailureDisposition {
|
|
if let failure = error as? CapacityDockProviderFetchFailure {
|
|
return failure.disposition
|
|
}
|
|
if let error = error as? ClinePassSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? CommandCodeSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? CursorSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? DevinSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? GrokBuildSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? GrokBotSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? ZaiSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if let error = error as? ZcodeSubscriptionService.FetchError {
|
|
switch error.classification {
|
|
case .terminalAuth:
|
|
return .terminal
|
|
case .transient, .parseFailure:
|
|
return .transient
|
|
}
|
|
}
|
|
if error is URLError {
|
|
return .transient
|
|
}
|
|
// Unknown adapter failures are treated as temporary. They must never
|
|
// erase a valid last-known connection merely because classification is
|
|
// incomplete.
|
|
return .transient
|
|
}
|
|
}
|