fc7dc9ca0d
* feat: add Codex OAuth provider flow * fix: harden Codex OAuth storage, session activation, and UI
456 lines
12 KiB
TypeScript
456 lines
12 KiB
TypeScript
import {
|
|
readCodexCredentialsAsync,
|
|
refreshCodexAccessTokenIfNeeded,
|
|
} from '../../utils/codexCredentials.js'
|
|
import { logForDebugging } from '../../utils/debug.js'
|
|
import { isBareMode } from '../../utils/envUtils.js'
|
|
import {
|
|
DEFAULT_CODEX_BASE_URL,
|
|
isCodexBaseUrl,
|
|
resolveRuntimeCodexCredentials,
|
|
resolveProviderRequest,
|
|
} from './providerConfig.js'
|
|
|
|
export type CodexUsageWindow = {
|
|
usedPercent: number
|
|
windowMinutes?: number
|
|
resetsAt?: string
|
|
}
|
|
|
|
export type CodexUsageCredits = {
|
|
hasCredits: boolean
|
|
unlimited: boolean
|
|
balance?: string
|
|
}
|
|
|
|
export type CodexUsageSnapshot = {
|
|
limitName: string
|
|
primary?: CodexUsageWindow
|
|
secondary?: CodexUsageWindow
|
|
credits?: CodexUsageCredits
|
|
}
|
|
|
|
export type CodexUsageData = {
|
|
planType?: string
|
|
snapshots: CodexUsageSnapshot[]
|
|
}
|
|
|
|
export type CodexUsageRow =
|
|
| {
|
|
kind: 'window'
|
|
label: string
|
|
usedPercent: number
|
|
resetsAt?: string
|
|
}
|
|
| {
|
|
kind: 'text'
|
|
label: string
|
|
value: string
|
|
}
|
|
|
|
type RecordLike = Record<string, unknown>
|
|
|
|
function isRecord(value: unknown): value is RecordLike {
|
|
return typeof value === 'object' && value !== null
|
|
}
|
|
|
|
function asString(value: unknown): string | undefined {
|
|
return typeof value === 'string' && value.trim() ? value.trim() : undefined
|
|
}
|
|
|
|
function asNumber(value: unknown): number | undefined {
|
|
return typeof value === 'number' && Number.isFinite(value) ? value : undefined
|
|
}
|
|
|
|
function asBoolean(value: unknown): boolean | undefined {
|
|
return typeof value === 'boolean' ? value : undefined
|
|
}
|
|
|
|
function toIsoFromUnixSeconds(value: unknown): string | undefined {
|
|
const seconds = asNumber(value)
|
|
if (seconds === undefined) return undefined
|
|
return new Date(seconds * 1000).toISOString()
|
|
}
|
|
|
|
function normalizeWindow(value: unknown): CodexUsageWindow | undefined {
|
|
if (!isRecord(value)) return undefined
|
|
|
|
const usedPercent =
|
|
asNumber(value.used_percent) ?? asNumber(value.usedPercent)
|
|
if (usedPercent === undefined) return undefined
|
|
|
|
const windowMinutes =
|
|
asNumber(value.window_minutes) ??
|
|
asNumber(value.windowDurationMins) ??
|
|
(() => {
|
|
const seconds = asNumber(value.limit_window_seconds)
|
|
return seconds === undefined ? undefined : Math.round(seconds / 60)
|
|
})()
|
|
|
|
const resetsAt =
|
|
toIsoFromUnixSeconds(value.resets_at) ??
|
|
toIsoFromUnixSeconds(value.resetsAt) ??
|
|
toIsoFromUnixSeconds(value.reset_at)
|
|
|
|
return {
|
|
usedPercent,
|
|
windowMinutes,
|
|
resetsAt,
|
|
}
|
|
}
|
|
|
|
function normalizeCredits(value: unknown): CodexUsageCredits | undefined {
|
|
if (!isRecord(value)) return undefined
|
|
|
|
const hasCredits =
|
|
asBoolean(value.has_credits) ?? asBoolean(value.hasCredits) ?? false
|
|
const unlimited = asBoolean(value.unlimited) ?? false
|
|
const balance = asString(value.balance)
|
|
|
|
if (!hasCredits && !unlimited && !balance) {
|
|
return undefined
|
|
}
|
|
|
|
return {
|
|
hasCredits,
|
|
unlimited,
|
|
balance,
|
|
}
|
|
}
|
|
|
|
function normalizeSnapshot(
|
|
value: unknown,
|
|
fallbackLimitName: string,
|
|
): CodexUsageSnapshot | undefined {
|
|
if (!isRecord(value)) return undefined
|
|
|
|
const limitName =
|
|
asString(value.limit_name) ??
|
|
asString(value.limitName) ??
|
|
asString(value.limit_id) ??
|
|
asString(value.limitId) ??
|
|
fallbackLimitName
|
|
|
|
const primary =
|
|
normalizeWindow(value.primary) ?? normalizeWindow(value.primary_window)
|
|
const secondary =
|
|
normalizeWindow(value.secondary) ?? normalizeWindow(value.secondary_window)
|
|
const credits = normalizeCredits(value.credits)
|
|
|
|
if (!primary && !secondary && !credits) {
|
|
return undefined
|
|
}
|
|
|
|
return {
|
|
limitName,
|
|
primary,
|
|
secondary,
|
|
credits,
|
|
}
|
|
}
|
|
|
|
function normalizeSnapshotsFromCollection(
|
|
value: unknown,
|
|
defaultLimitName = 'codex',
|
|
): CodexUsageSnapshot[] {
|
|
if (Array.isArray(value)) {
|
|
return value
|
|
.map((item, index) =>
|
|
normalizeSnapshot(
|
|
item,
|
|
index === 0 ? defaultLimitName : `${defaultLimitName}-${index + 1}`,
|
|
),
|
|
)
|
|
.filter((item): item is CodexUsageSnapshot => item !== undefined)
|
|
}
|
|
|
|
if (!isRecord(value)) return []
|
|
|
|
return Object.entries(value)
|
|
.map(([key, entry]) => normalizeSnapshot(entry, key))
|
|
.filter((item): item is CodexUsageSnapshot => item !== undefined)
|
|
}
|
|
|
|
function normalizeLiveUsagePayload(payload: RecordLike): CodexUsageData {
|
|
const planType = asString(payload.plan_type) ?? asString(payload.planType)
|
|
const snapshots: CodexUsageSnapshot[] = []
|
|
const codexCredits = normalizeCredits(payload.credits)
|
|
|
|
const codexSnapshot = normalizeSnapshot(payload.rate_limit, 'codex')
|
|
if (codexSnapshot) {
|
|
codexSnapshot.credits ??= codexCredits
|
|
snapshots.push(codexSnapshot)
|
|
} else if (codexCredits) {
|
|
snapshots.push({
|
|
limitName: 'codex',
|
|
credits: codexCredits,
|
|
})
|
|
}
|
|
|
|
const codeReviewSnapshot = normalizeSnapshot(
|
|
payload.code_review_rate_limit,
|
|
'code review',
|
|
)
|
|
if (codeReviewSnapshot) {
|
|
snapshots.push(codeReviewSnapshot)
|
|
}
|
|
|
|
snapshots.push(
|
|
...normalizeSnapshotsFromCollection(
|
|
payload.additional_rate_limits ?? payload.additionalRateLimits,
|
|
'additional',
|
|
),
|
|
)
|
|
|
|
return {
|
|
planType,
|
|
snapshots,
|
|
}
|
|
}
|
|
|
|
export function normalizeCodexUsagePayload(payload: unknown): CodexUsageData {
|
|
if (Array.isArray(payload)) {
|
|
return {
|
|
snapshots: normalizeSnapshotsFromCollection(payload),
|
|
}
|
|
}
|
|
|
|
if (!isRecord(payload)) {
|
|
return { snapshots: [] }
|
|
}
|
|
|
|
if (
|
|
'rate_limit' in payload ||
|
|
'code_review_rate_limit' in payload ||
|
|
'additional_rate_limits' in payload ||
|
|
'credits' in payload
|
|
) {
|
|
return normalizeLiveUsagePayload(payload)
|
|
}
|
|
|
|
const collection =
|
|
payload.rate_limits ??
|
|
payload.rateLimits ??
|
|
payload.rate_limits_by_limit_id ??
|
|
payload.rateLimitsByLimitId
|
|
|
|
if (collection !== undefined) {
|
|
return {
|
|
planType: asString(payload.plan_type) ?? asString(payload.planType),
|
|
snapshots: normalizeSnapshotsFromCollection(collection),
|
|
}
|
|
}
|
|
|
|
const snapshot = normalizeSnapshot(payload, 'codex')
|
|
return {
|
|
planType: asString(payload.plan_type) ?? asString(payload.planType),
|
|
snapshots: snapshot ? [snapshot] : [],
|
|
}
|
|
}
|
|
|
|
function capitalizeFirst(value: string): string {
|
|
if (!value) return value
|
|
return value[0]!.toUpperCase() + value.slice(1)
|
|
}
|
|
|
|
function formatWindowDuration(
|
|
windowMinutes: number | undefined,
|
|
fallback: string,
|
|
): string {
|
|
if (windowMinutes === undefined || windowMinutes <= 0) {
|
|
return fallback
|
|
}
|
|
|
|
if (windowMinutes === 60 * 24 * 7) {
|
|
return 'weekly'
|
|
}
|
|
|
|
if (windowMinutes % (60 * 24) === 0) {
|
|
return `${windowMinutes / (60 * 24)}d`
|
|
}
|
|
|
|
if (windowMinutes % 60 === 0) {
|
|
return `${windowMinutes / 60}h`
|
|
}
|
|
|
|
return `${windowMinutes}m`
|
|
}
|
|
|
|
function formatCreditBalance(rawBalance: string | undefined): string | undefined {
|
|
const balance = rawBalance?.trim()
|
|
if (!balance) return undefined
|
|
|
|
const intValue = Number.parseInt(balance, 10)
|
|
if (Number.isFinite(intValue) && `${intValue}` === balance && intValue > 0) {
|
|
return `${intValue}`
|
|
}
|
|
|
|
const floatValue = Number.parseFloat(balance)
|
|
if (Number.isFinite(floatValue) && floatValue > 0) {
|
|
return `${Math.round(floatValue)}`
|
|
}
|
|
|
|
return undefined
|
|
}
|
|
|
|
function buildCreditsRow(
|
|
credits: CodexUsageCredits | undefined,
|
|
): CodexUsageRow | undefined {
|
|
if (!credits?.hasCredits) return undefined
|
|
if (credits.unlimited) {
|
|
return {
|
|
kind: 'text',
|
|
label: 'Credits',
|
|
value: 'Unlimited',
|
|
}
|
|
}
|
|
|
|
const displayBalance = formatCreditBalance(credits.balance)
|
|
if (!displayBalance) return undefined
|
|
|
|
return {
|
|
kind: 'text',
|
|
label: 'Credits',
|
|
value: `${displayBalance} credits`,
|
|
}
|
|
}
|
|
|
|
export function buildCodexUsageRows(
|
|
snapshots: CodexUsageSnapshot[],
|
|
): CodexUsageRow[] {
|
|
const rows: CodexUsageRow[] = []
|
|
|
|
for (const snapshot of snapshots) {
|
|
const limitBucketLabel = snapshot.limitName.trim() || 'codex'
|
|
const creditsRow = buildCreditsRow(snapshot.credits)
|
|
const hasRenderableContent =
|
|
snapshot.primary !== undefined ||
|
|
snapshot.secondary !== undefined ||
|
|
creditsRow !== undefined
|
|
if (!hasRenderableContent) {
|
|
continue
|
|
}
|
|
|
|
const showLimitPrefix = limitBucketLabel.toLowerCase() !== 'codex'
|
|
const windowCount =
|
|
Number(snapshot.primary !== undefined) +
|
|
Number(snapshot.secondary !== undefined)
|
|
const combineNonCodexSingleLimit = showLimitPrefix && windowCount === 1
|
|
|
|
if (showLimitPrefix && !combineNonCodexSingleLimit) {
|
|
rows.push({
|
|
kind: 'text',
|
|
label: `${capitalizeFirst(limitBucketLabel)} limit`,
|
|
value: '',
|
|
})
|
|
}
|
|
|
|
if (snapshot.primary) {
|
|
const durationLabel = capitalizeFirst(
|
|
formatWindowDuration(snapshot.primary.windowMinutes, '5h'),
|
|
)
|
|
rows.push({
|
|
kind: 'window',
|
|
label: combineNonCodexSingleLimit
|
|
? `${capitalizeFirst(limitBucketLabel)} ${durationLabel} limit`
|
|
: `${durationLabel} limit`,
|
|
usedPercent: snapshot.primary.usedPercent,
|
|
resetsAt: snapshot.primary.resetsAt,
|
|
})
|
|
}
|
|
|
|
if (snapshot.secondary) {
|
|
const durationLabel = capitalizeFirst(
|
|
formatWindowDuration(snapshot.secondary.windowMinutes, 'weekly'),
|
|
)
|
|
rows.push({
|
|
kind: 'window',
|
|
label: combineNonCodexSingleLimit
|
|
? `${capitalizeFirst(limitBucketLabel)} ${durationLabel} limit`
|
|
: `${durationLabel} limit`,
|
|
usedPercent: snapshot.secondary.usedPercent,
|
|
resetsAt: snapshot.secondary.resetsAt,
|
|
})
|
|
}
|
|
|
|
if (creditsRow) {
|
|
rows.push(creditsRow)
|
|
}
|
|
}
|
|
|
|
return rows
|
|
}
|
|
|
|
export function formatCodexPlanType(
|
|
planType: string | undefined,
|
|
): string | undefined {
|
|
if (!planType) return undefined
|
|
return planType
|
|
.split(/[_\s-]+/)
|
|
.filter(Boolean)
|
|
.map(part => capitalizeFirst(part.toLowerCase()))
|
|
.join(' ')
|
|
}
|
|
|
|
export function getCodexUsageUrl(baseUrl = DEFAULT_CODEX_BASE_URL): string {
|
|
return new URL('/backend-api/wham/usage', baseUrl).toString()
|
|
}
|
|
|
|
export async function fetchCodexUsage(): Promise<CodexUsageData> {
|
|
const refreshResult = await refreshCodexAccessTokenIfNeeded().catch(
|
|
async error => {
|
|
logForDebugging(
|
|
`[codex] access token refresh failed before usage fetch: ${error instanceof Error ? error.message : String(error)}`,
|
|
{ level: 'warn' },
|
|
)
|
|
return {
|
|
refreshed: false,
|
|
credentials: await readCodexCredentialsAsync(),
|
|
}
|
|
},
|
|
)
|
|
const request = resolveProviderRequest({
|
|
model: process.env.OPENAI_MODEL,
|
|
baseUrl: process.env.OPENAI_BASE_URL,
|
|
})
|
|
if (!isCodexBaseUrl(request.baseUrl)) {
|
|
throw new Error(
|
|
'Codex usage is only available with the official ChatGPT Codex backend.',
|
|
)
|
|
}
|
|
|
|
const credentials = resolveRuntimeCodexCredentials({
|
|
storedCredentials: refreshResult.credentials,
|
|
})
|
|
if (!credentials.apiKey) {
|
|
const oauthHint = isBareMode() ? '' : ', choose Codex OAuth in /provider'
|
|
const authHint = credentials.authPath
|
|
? `${oauthHint} or place a Codex auth.json at ${credentials.authPath}`
|
|
: oauthHint
|
|
throw new Error(`Codex auth is required. Set CODEX_API_KEY${authHint}.`)
|
|
}
|
|
if (!credentials.accountId) {
|
|
throw new Error(
|
|
'Codex auth is missing chatgpt_account_id. Re-login with Codex OAuth, the Codex CLI, or set CHATGPT_ACCOUNT_ID/CODEX_ACCOUNT_ID.',
|
|
)
|
|
}
|
|
|
|
const response = await fetch(getCodexUsageUrl(request.baseUrl), {
|
|
method: 'GET',
|
|
headers: {
|
|
Accept: 'application/json',
|
|
Authorization: `Bearer ${credentials.apiKey}`,
|
|
'chatgpt-account-id': credentials.accountId,
|
|
originator: 'openclaude',
|
|
},
|
|
signal: AbortSignal.timeout(5000),
|
|
})
|
|
|
|
if (!response.ok) {
|
|
const errorBody = await response.text().catch(() => 'unknown error')
|
|
throw new Error(`Codex usage error ${response.status}: ${errorBody}`)
|
|
}
|
|
|
|
return normalizeCodexUsagePayload(await response.json())
|
|
}
|