From 5c25ac4e9acb12ce8a7f0f89e54bb7b01a6a0b93 Mon Sep 17 00:00:00 2001 From: erdemozyol <26572407+erdemozyol@users.noreply.github.com> Date: Thu, 2 Apr 2026 17:37:07 +0300 Subject: [PATCH] Add Codex usage to /status --- src/components/Settings/CodexUsage.tsx | 211 ++++++++++++ src/components/Settings/Usage.tsx | 12 +- src/services/api/codexUsage.test.ts | 204 ++++++++++++ src/services/api/codexUsage.ts | 434 +++++++++++++++++++++++++ 4 files changed, 859 insertions(+), 2 deletions(-) create mode 100644 src/components/Settings/CodexUsage.tsx create mode 100644 src/services/api/codexUsage.test.ts create mode 100644 src/services/api/codexUsage.ts diff --git a/src/components/Settings/CodexUsage.tsx b/src/components/Settings/CodexUsage.tsx new file mode 100644 index 00000000..83a95afc --- /dev/null +++ b/src/components/Settings/CodexUsage.tsx @@ -0,0 +1,211 @@ +import * as React from 'react' +import { useEffect, useState } from 'react' + +import { useTerminalSize } from '../../hooks/useTerminalSize.js' +import { Box, Text } from '../../ink.js' +import { useKeybinding } from '../../keybindings/useKeybinding.js' +import { + buildCodexUsageRows, + fetchCodexUsage, + formatCodexPlanType, + type CodexUsageData, + type CodexUsageRow, +} from '../../services/api/codexUsage.js' +import { formatResetText } from '../../utils/format.js' +import { logError } from '../../utils/log.js' +import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js' +import { Byline } from '../design-system/Byline.js' +import { ProgressBar } from '../design-system/ProgressBar.js' + +type CodexUsageLimitBarProps = { + label: string + usedPercent: number + resetsAt?: string + maxWidth: number +} + +function CodexUsageLimitBar({ + label, + usedPercent, + resetsAt, + maxWidth, +}: CodexUsageLimitBarProps): React.ReactNode { + const normalizedUsedPercent = Math.max(0, Math.min(100, usedPercent)) + const usedText = `${Math.floor(normalizedUsedPercent)}% used` + const resetText = resetsAt + ? `Resets ${formatResetText(resetsAt, true, true)}` + : undefined + + if (maxWidth >= 62) { + return ( + + {label} + + + {usedText} + + {resetText ? {resetText} : null} + + ) + } + + return ( + + + {label} + {resetText ? ( + <> + + · {resetText} + + ) : null} + + + {usedText} + + ) +} + +function CodexUsageTextRow({ + label, + value, +}: Extract): React.ReactNode { + if (!value) { + return {label} + } + + return ( + + {label} + · {value} + + ) +} + +export function CodexUsage(): React.ReactNode { + const [usage, setUsage] = useState(null) + const [error, setError] = useState(null) + const [isLoading, setIsLoading] = useState(true) + const { columns } = useTerminalSize() + const availableWidth = columns - 2 + const maxWidth = Math.min(availableWidth, 80) + + const loadUsage = React.useCallback(async () => { + setIsLoading(true) + setError(null) + + try { + setUsage(await fetchCodexUsage()) + } catch (err) { + logError(err as Error) + setError(err instanceof Error ? err.message : 'Failed to load Codex usage') + } finally { + setIsLoading(false) + } + }, []) + + useEffect(() => { + void loadUsage() + }, [loadUsage]) + + useKeybinding( + 'settings:retry', + () => { + void loadUsage() + }, + { + context: 'Settings', + isActive: !!error && !isLoading, + }, + ) + + if (error) { + return ( + + Error: {error} + + + + + + + + ) + } + + if (!usage) { + return ( + + Loading Codex usage data… + + + + + ) + } + + const rows = buildCodexUsageRows(usage.snapshots) + const planType = formatCodexPlanType(usage.planType) + + return ( + + {planType ? Plan: {planType} : null} + + {rows.length === 0 ? ( + Codex usage data is not available for this account. + ) : null} + + {rows.map((row, index) => + row.kind === 'window' ? ( + + ) : ( + + ), + )} + + + + + + ) +} diff --git a/src/components/Settings/Usage.tsx b/src/components/Settings/Usage.tsx index b8c48631..3df75738 100644 --- a/src/components/Settings/Usage.tsx +++ b/src/components/Settings/Usage.tsx @@ -10,11 +10,13 @@ import { useKeybinding } from '../../keybindings/useKeybinding.js'; import { type ExtraUsage, fetchUtilization, type RateLimit, type Utilization } from '../../services/api/usage.js'; import { formatResetText } from '../../utils/format.js'; import { logError } from '../../utils/log.js'; +import { getAPIProvider } from '../../utils/model/providers.js'; import { jsonStringify } from '../../utils/slowOperations.js'; import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'; import { Byline } from '../design-system/Byline.js'; import { ProgressBar } from '../design-system/ProgressBar.js'; import { isEligibleForOverageCreditGrant, OverageCreditUpsell } from '../LogoV2/OverageCreditUpsell.js'; +import { CodexUsage } from './CodexUsage.js'; type LimitBarProps = { title: string; limit: RateLimit; @@ -171,7 +173,7 @@ function LimitBar(t0) { return t8; } } -export function Usage(): React.ReactNode { +function AnthropicUsage(): React.ReactNode { const [utilization, setUtilization] = useState(null); const [error, setError] = useState(null); const [isLoading, setIsLoading] = useState(true); @@ -263,6 +265,12 @@ export function Usage(): React.ReactNode { ; } +export function Usage(): React.ReactNode { + if (getAPIProvider() === 'codex') { + return ; + } + return ; +} type ExtraUsageSectionProps = { extraUsage: ExtraUsage; maxWidth: number; @@ -374,4 +382,4 @@ function ExtraUsageSection(t0) { } return t10; } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","extraUsage","extraUsageCommand","formatCost","getSubscriptionType","useTerminalSize","Box","Text","useKeybinding","ExtraUsage","fetchUtilization","RateLimit","Utilization","formatResetText","logError","jsonStringify","ConfigurableShortcutHint","Byline","ProgressBar","isEligibleForOverageCreditGrant","OverageCreditUpsell","LimitBarProps","title","limit","maxWidth","showTimeInReset","extraSubtext","LimitBar","t0","$","_c","t1","undefined","utilization","resets_at","usedText","Math","floor","subtext","t2","t3","t4","maxBarWidth","t5","t6","t7","t8","Usage","ReactNode","setUtilization","error","setError","isLoading","setIsLoading","columns","availableWidth","min","loadUtilization","useCallback","data","err","Error","axiosError","response","responseBody","context","isActive","subscriptionType","showSonnetBar","limits","five_hour","seven_day","seven_day_sonnet","some","map","extra_usage","ExtraUsageSectionProps","EXTRA_USAGE_SECTION_TITLE","ExtraUsageSection","isProOrMax","is_enabled","isEnabled","Symbol","for","monthly_limit","used_credits","formattedUsedCredits","formattedMonthlyLimit","T0","now","Date","oneMonthReset","getFullYear","getMonth","toISOString","t9","t10"],"sources":["Usage.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { extraUsage as extraUsageCommand } from 'src/commands/extra-usage/index.js'\nimport { formatCost } from 'src/cost-tracker.js'\nimport { getSubscriptionType } from 'src/utils/auth.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  type ExtraUsage,\n  fetchUtilization,\n  type RateLimit,\n  type Utilization,\n} from '../../services/api/usage.js'\nimport { formatResetText } from '../../utils/format.js'\nimport { logError } from '../../utils/log.js'\nimport { jsonStringify } from '../../utils/slowOperations.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { ProgressBar } from '../design-system/ProgressBar.js'\nimport {\n  isEligibleForOverageCreditGrant,\n  OverageCreditUpsell,\n} from '../LogoV2/OverageCreditUpsell.js'\n\ntype LimitBarProps = {\n  title: string\n  limit: RateLimit\n  maxWidth: number\n  showTimeInReset?: boolean\n  extraSubtext?: string\n}\n\nfunction LimitBar({\n  title,\n  limit,\n  maxWidth,\n  showTimeInReset = true,\n  extraSubtext,\n}: LimitBarProps): React.ReactNode {\n  const { utilization, resets_at } = limit\n  if (utilization === null) {\n    return null\n  }\n\n  // Calculate usage percentage\n  const usedText = `${Math.floor(utilization)}% used`\n\n  let subtext: string | undefined\n  if (resets_at) {\n    subtext = `Resets ${formatResetText(resets_at, true, showTimeInReset)}`\n  }\n\n  if (extraSubtext) {\n    if (subtext) {\n      subtext = `${extraSubtext} · ${subtext}`\n    } else {\n      subtext = extraSubtext\n    }\n  }\n\n  const maxBarWidth = 50\n  const usedLabelSpace = 12\n  if (maxWidth >= maxBarWidth + usedLabelSpace) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{title}</Text>\n        <Box flexDirection=\"row\" gap={1}>\n          <ProgressBar\n            ratio={utilization / 100}\n            width={maxBarWidth}\n            fillColor=\"rate_limit_fill\"\n            emptyColor=\"rate_limit_empty\"\n          />\n          <Text>{usedText}</Text>\n        </Box>\n        {subtext && <Text dimColor>{subtext}</Text>}\n      </Box>\n    )\n  } else {\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          <Text bold>{title}</Text>\n          {subtext && (\n            <>\n              <Text> </Text>\n              <Text dimColor>· {subtext}</Text>\n            </>\n          )}\n        </Text>\n        <ProgressBar\n          ratio={utilization / 100}\n          width={maxWidth}\n          fillColor=\"rate_limit_fill\"\n          emptyColor=\"rate_limit_empty\"\n        />\n        <Text>{usedText}</Text>\n      </Box>\n    )\n  }\n}\n\nexport function Usage(): React.ReactNode {\n  const [utilization, setUtilization] = useState<Utilization | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const [isLoading, setIsLoading] = useState(true)\n  const { columns } = useTerminalSize()\n\n  const availableWidth = columns - 2 // 2 for screen padding\n  const maxWidth = Math.min(availableWidth, 80)\n\n  const loadUtilization = React.useCallback(async () => {\n    setIsLoading(true)\n    setError(null)\n    try {\n      const data = await fetchUtilization()\n      setUtilization(data)\n    } catch (err) {\n      logError(err as Error)\n      const axiosError = err as { response?: { data?: unknown } }\n      const responseBody = axiosError.response?.data\n        ? jsonStringify(axiosError.response.data)\n        : undefined\n      setError(\n        responseBody\n          ? `Failed to load usage data: ${responseBody}`\n          : 'Failed to load usage data',\n      )\n    } finally {\n      setIsLoading(false)\n    }\n  }, [])\n\n  useEffect(() => {\n    void loadUtilization()\n  }, [loadUtilization])\n\n  useKeybinding(\n    'settings:retry',\n    () => {\n      void loadUtilization()\n    },\n    { context: 'Settings', isActive: !!error && !isLoading },\n  )\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Error: {error}</Text>\n        <Text dimColor>\n          <Byline>\n            <ConfigurableShortcutHint\n              action=\"settings:retry\"\n              context=\"Settings\"\n              fallback=\"r\"\n              description=\"retry\"\n            />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Settings\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    )\n  }\n\n  if (!utilization) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text dimColor>Loading usage data…</Text>\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        </Text>\n      </Box>\n    )\n  }\n\n  // Only Max and Team plans have a Sonnet limit that differs from the weekly\n  // limit (see rateLimitMessages.ts). For other plans the bar is redundant.\n  // Show for null (unknown plan) to stay consistent with rateLimitMessages.ts,\n  // which labels it \"Sonnet limit\" in that case.\n  const subscriptionType = getSubscriptionType()\n  const showSonnetBar =\n    subscriptionType === 'max' ||\n    subscriptionType === 'team' ||\n    subscriptionType === null\n\n  const limits = [\n    {\n      title: 'Current session',\n      limit: utilization.five_hour,\n    },\n    {\n      title: 'Current week (all models)',\n      limit: utilization.seven_day,\n    },\n    ...(showSonnetBar\n      ? [\n          {\n            title: 'Current week (Sonnet only)',\n            limit: utilization.seven_day_sonnet,\n          },\n        ]\n      : []),\n  ]\n\n  return (\n    <Box flexDirection=\"column\" gap={1} width=\"100%\">\n      {limits.some(({ limit }) => limit) || (\n        <Text dimColor>/usage is only available for subscription plans.</Text>\n      )}\n\n      {limits.map(\n        ({ title, limit }) =>\n          limit && (\n            <LimitBar\n              key={title}\n              title={title}\n              limit={limit}\n              maxWidth={maxWidth}\n            />\n          ),\n      )}\n\n      {utilization.extra_usage && (\n        <ExtraUsageSection\n          extraUsage={utilization.extra_usage}\n          maxWidth={maxWidth}\n        />\n      )}\n\n      {isEligibleForOverageCreditGrant() && (\n        <OverageCreditUpsell maxWidth={maxWidth} />\n      )}\n\n      <Text dimColor>\n        <ConfigurableShortcutHint\n          action=\"confirm:no\"\n          context=\"Settings\"\n          fallback=\"Esc\"\n          description=\"cancel\"\n        />\n      </Text>\n    </Box>\n  )\n}\n\ntype ExtraUsageSectionProps = {\n  extraUsage: ExtraUsage\n  maxWidth: number\n}\n\nconst EXTRA_USAGE_SECTION_TITLE = 'Extra usage'\n\nfunction ExtraUsageSection({\n  extraUsage,\n  maxWidth,\n}: ExtraUsageSectionProps): React.ReactNode {\n  const subscriptionType = getSubscriptionType()\n  const isProOrMax = subscriptionType === 'pro' || subscriptionType === 'max'\n  if (!isProOrMax) {\n    // Only show to Pro and Max, consistent with claude.ai non-admin usage settings\n    return false\n  }\n\n  if (!extraUsage.is_enabled) {\n    if (extraUsageCommand.isEnabled()) {\n      return (\n        <Box flexDirection=\"column\">\n          <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n          <Text dimColor>Extra usage not enabled · /extra-usage to enable</Text>\n        </Box>\n      )\n    }\n\n    return null\n  }\n\n  if (extraUsage.monthly_limit === null) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n        <Text dimColor>Unlimited</Text>\n      </Box>\n    )\n  }\n\n  if (\n    typeof extraUsage.used_credits !== 'number' ||\n    typeof extraUsage.utilization !== 'number'\n  ) {\n    return null\n  }\n\n  const formattedUsedCredits = formatCost(extraUsage.used_credits / 100, 2)\n  const formattedMonthlyLimit = formatCost(extraUsage.monthly_limit / 100, 2)\n  const now = new Date()\n  const oneMonthReset = new Date(now.getFullYear(), now.getMonth() + 1, 1)\n\n  return (\n    <LimitBar\n      title={EXTRA_USAGE_SECTION_TITLE}\n      limit={{\n        utilization: extraUsage.utilization,\n        // Not applicable for enterprises, but for now we don't render this for them\n        resets_at: oneMonthReset.toISOString(),\n      }}\n      showTimeInReset={false}\n      extraSubtext={`${formattedUsedCredits} / ${formattedMonthlyLimit} spent`}\n      maxWidth={maxWidth}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","extraUsage","extraUsageCommand","formatCost","getSubscriptionType","useTerminalSize","Box","Text","useKeybinding","ExtraUsage","fetchUtilization","RateLimit","Utilization","formatResetText","logError","jsonStringify","ConfigurableShortcutHint","Byline","ProgressBar","isEligibleForOverageCreditGrant","OverageCreditUpsell","LimitBarProps","title","limit","maxWidth","showTimeInReset","extraSubtext","LimitBar","t0","$","_c","t1","undefined","utilization","resets_at","usedText","Math","floor","subtext","t2","t3","t4","maxBarWidth","t5","t6","t7","t8","Usage","ReactNode","setUtilization","error","setError","isLoading","setIsLoading","columns","availableWidth","min","loadUtilization","useCallback","data","err","Error","axiosError","response","responseBody","context","isActive","subscriptionType","showSonnetBar","limits","five_hour","seven_day","seven_day_sonnet","some","map","extra_usage","ExtraUsageSectionProps","EXTRA_USAGE_SECTION_TITLE","ExtraUsageSection","isProOrMax","is_enabled","isEnabled","Symbol","for","monthly_limit","used_credits","formattedUsedCredits","formattedMonthlyLimit","T0","now","Date","oneMonthReset","getFullYear","getMonth","toISOString","t9","t10"],"sources":["Usage.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { extraUsage as extraUsageCommand } from 'src/commands/extra-usage/index.js'\nimport { formatCost } from 'src/cost-tracker.js'\nimport { getSubscriptionType } from 'src/utils/auth.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  type ExtraUsage,\n  fetchUtilization,\n  type RateLimit,\n  type Utilization,\n} from '../../services/api/usage.js'\nimport { formatResetText } from '../../utils/format.js'\nimport { logError } from '../../utils/log.js'\nimport { jsonStringify } from '../../utils/slowOperations.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { ProgressBar } from '../design-system/ProgressBar.js'\nimport {\n  isEligibleForOverageCreditGrant,\n  OverageCreditUpsell,\n} from '../LogoV2/OverageCreditUpsell.js'\n\ntype LimitBarProps = {\n  title: string\n  limit: RateLimit\n  maxWidth: number\n  showTimeInReset?: boolean\n  extraSubtext?: string\n}\n\nfunction LimitBar({\n  title,\n  limit,\n  maxWidth,\n  showTimeInReset = true,\n  extraSubtext,\n}: LimitBarProps): React.ReactNode {\n  const { utilization, resets_at } = limit\n  if (utilization === null) {\n    return null\n  }\n\n  // Calculate usage percentage\n  const usedText = `${Math.floor(utilization)}% used`\n\n  let subtext: string | undefined\n  if (resets_at) {\n    subtext = `Resets ${formatResetText(resets_at, true, showTimeInReset)}`\n  }\n\n  if (extraSubtext) {\n    if (subtext) {\n      subtext = `${extraSubtext} · ${subtext}`\n    } else {\n      subtext = extraSubtext\n    }\n  }\n\n  const maxBarWidth = 50\n  const usedLabelSpace = 12\n  if (maxWidth >= maxBarWidth + usedLabelSpace) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{title}</Text>\n        <Box flexDirection=\"row\" gap={1}>\n          <ProgressBar\n            ratio={utilization / 100}\n            width={maxBarWidth}\n            fillColor=\"rate_limit_fill\"\n            emptyColor=\"rate_limit_empty\"\n          />\n          <Text>{usedText}</Text>\n        </Box>\n        {subtext && <Text dimColor>{subtext}</Text>}\n      </Box>\n    )\n  } else {\n    return (\n      <Box flexDirection=\"column\">\n        <Text>\n          <Text bold>{title}</Text>\n          {subtext && (\n            <>\n              <Text> </Text>\n              <Text dimColor>· {subtext}</Text>\n            </>\n          )}\n        </Text>\n        <ProgressBar\n          ratio={utilization / 100}\n          width={maxWidth}\n          fillColor=\"rate_limit_fill\"\n          emptyColor=\"rate_limit_empty\"\n        />\n        <Text>{usedText}</Text>\n      </Box>\n    )\n  }\n}\n\nexport function Usage(): React.ReactNode {\n  const [utilization, setUtilization] = useState<Utilization | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const [isLoading, setIsLoading] = useState(true)\n  const { columns } = useTerminalSize()\n\n  const availableWidth = columns - 2 // 2 for screen padding\n  const maxWidth = Math.min(availableWidth, 80)\n\n  const loadUtilization = React.useCallback(async () => {\n    setIsLoading(true)\n    setError(null)\n    try {\n      const data = await fetchUtilization()\n      setUtilization(data)\n    } catch (err) {\n      logError(err as Error)\n      const axiosError = err as { response?: { data?: unknown } }\n      const responseBody = axiosError.response?.data\n        ? jsonStringify(axiosError.response.data)\n        : undefined\n      setError(\n        responseBody\n          ? `Failed to load usage data: ${responseBody}`\n          : 'Failed to load usage data',\n      )\n    } finally {\n      setIsLoading(false)\n    }\n  }, [])\n\n  useEffect(() => {\n    void loadUtilization()\n  }, [loadUtilization])\n\n  useKeybinding(\n    'settings:retry',\n    () => {\n      void loadUtilization()\n    },\n    { context: 'Settings', isActive: !!error && !isLoading },\n  )\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Error: {error}</Text>\n        <Text dimColor>\n          <Byline>\n            <ConfigurableShortcutHint\n              action=\"settings:retry\"\n              context=\"Settings\"\n              fallback=\"r\"\n              description=\"retry\"\n            />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Settings\"\n              fallback=\"Esc\"\n              description=\"cancel\"\n            />\n          </Byline>\n        </Text>\n      </Box>\n    )\n  }\n\n  if (!utilization) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text dimColor>Loading usage data…</Text>\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Settings\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        </Text>\n      </Box>\n    )\n  }\n\n  // Only Max and Team plans have a Sonnet limit that differs from the weekly\n  // limit (see rateLimitMessages.ts). For other plans the bar is redundant.\n  // Show for null (unknown plan) to stay consistent with rateLimitMessages.ts,\n  // which labels it \"Sonnet limit\" in that case.\n  const subscriptionType = getSubscriptionType()\n  const showSonnetBar =\n    subscriptionType === 'max' ||\n    subscriptionType === 'team' ||\n    subscriptionType === null\n\n  const limits = [\n    {\n      title: 'Current session',\n      limit: utilization.five_hour,\n    },\n    {\n      title: 'Current week (all models)',\n      limit: utilization.seven_day,\n    },\n    ...(showSonnetBar\n      ? [\n          {\n            title: 'Current week (Sonnet only)',\n            limit: utilization.seven_day_sonnet,\n          },\n        ]\n      : []),\n  ]\n\n  return (\n    <Box flexDirection=\"column\" gap={1} width=\"100%\">\n      {limits.some(({ limit }) => limit) || (\n        <Text dimColor>/usage is only available for subscription plans.</Text>\n      )}\n\n      {limits.map(\n        ({ title, limit }) =>\n          limit && (\n            <LimitBar\n              key={title}\n              title={title}\n              limit={limit}\n              maxWidth={maxWidth}\n            />\n          ),\n      )}\n\n      {utilization.extra_usage && (\n        <ExtraUsageSection\n          extraUsage={utilization.extra_usage}\n          maxWidth={maxWidth}\n        />\n      )}\n\n      {isEligibleForOverageCreditGrant() && (\n        <OverageCreditUpsell maxWidth={maxWidth} />\n      )}\n\n      <Text dimColor>\n        <ConfigurableShortcutHint\n          action=\"confirm:no\"\n          context=\"Settings\"\n          fallback=\"Esc\"\n          description=\"cancel\"\n        />\n      </Text>\n    </Box>\n  )\n}\n\ntype ExtraUsageSectionProps = {\n  extraUsage: ExtraUsage\n  maxWidth: number\n}\n\nconst EXTRA_USAGE_SECTION_TITLE = 'Extra usage'\n\nfunction ExtraUsageSection({\n  extraUsage,\n  maxWidth,\n}: ExtraUsageSectionProps): React.ReactNode {\n  const subscriptionType = getSubscriptionType()\n  const isProOrMax = subscriptionType === 'pro' || subscriptionType === 'max'\n  if (!isProOrMax) {\n    // Only show to Pro and Max, consistent with claude.ai non-admin usage settings\n    return false\n  }\n\n  if (!extraUsage.is_enabled) {\n    if (extraUsageCommand.isEnabled()) {\n      return (\n        <Box flexDirection=\"column\">\n          <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n          <Text dimColor>Extra usage not enabled · /extra-usage to enable</Text>\n        </Box>\n      )\n    }\n\n    return null\n  }\n\n  if (extraUsage.monthly_limit === null) {\n    return (\n      <Box flexDirection=\"column\">\n        <Text bold>{EXTRA_USAGE_SECTION_TITLE}</Text>\n        <Text dimColor>Unlimited</Text>\n      </Box>\n    )\n  }\n\n  if (\n    typeof extraUsage.used_credits !== 'number' ||\n    typeof extraUsage.utilization !== 'number'\n  ) {\n    return null\n  }\n\n  const formattedUsedCredits = formatCost(extraUsage.used_credits / 100, 2)\n  const formattedMonthlyLimit = formatCost(extraUsage.monthly_limit / 100, 2)\n  const now = new Date()\n  const oneMonthReset = new Date(now.getFullYear(), now.getMonth() + 1, 1)\n\n  return (\n    <LimitBar\n      title={EXTRA_USAGE_SECTION_TITLE}\n      limit={{\n        utilization: extraUsage.utilization,\n        // Not applicable for enterprises, but for now we don't render this for them\n        resets_at: oneMonthReset.toISOString(),\n      }}\n      showTimeInReset={false}\n      extraSubtext={`${formattedUsedCredits} / ${formattedMonthlyLimit} spent`}\n      maxWidth={maxWidth}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]} diff --git a/src/services/api/codexUsage.test.ts b/src/services/api/codexUsage.test.ts new file mode 100644 index 00000000..7d775ffe --- /dev/null +++ b/src/services/api/codexUsage.test.ts @@ -0,0 +1,204 @@ +import { describe, expect, test } from 'bun:test' + +import { + buildCodexUsageRows, + formatCodexPlanType, + getCodexUsageUrl, + normalizeCodexUsagePayload, +} from './codexUsage.js' + +describe('normalizeCodexUsagePayload', () => { + test('normalizes live Codex usage payloads from /backend-api/wham/usage', () => { + const usage = normalizeCodexUsagePayload({ + plan_type: 'plus', + rate_limit: { + primary_window: { + used_percent: 38, + limit_window_seconds: 18_000, + reset_at: 1_775_154_358, + }, + secondary_window: { + used_percent: 32, + limit_window_seconds: 604_800, + reset_at: 1_775_685_041, + }, + }, + code_review_rate_limit: { + primary_window: { + used_percent: 0, + limit_window_seconds: 604_800, + reset_at: 1_775_744_471, + }, + secondary_window: null, + }, + credits: { + has_credits: false, + unlimited: false, + balance: '0', + }, + }) + + expect(usage.planType).toBe('plus') + expect(usage.snapshots).toHaveLength(2) + expect(usage.snapshots[0]).toMatchObject({ + limitName: 'codex', + primary: { + usedPercent: 38, + windowMinutes: 300, + }, + secondary: { + usedPercent: 32, + windowMinutes: 10_080, + }, + }) + expect(usage.snapshots[1]).toMatchObject({ + limitName: 'code review', + primary: { + usedPercent: 0, + windowMinutes: 10_080, + }, + }) + }) + + test('supports direct protocol-style snapshot collections', () => { + const usage = normalizeCodexUsagePayload({ + rateLimitsByLimitId: { + codex: { + limit_name: 'codex', + primary: { + used_percent: 12, + window_minutes: 300, + resets_at: 1_700_000_000, + }, + credits: { + has_credits: true, + unlimited: false, + balance: '25', + }, + }, + }, + }) + + expect(usage.snapshots).toEqual([ + { + limitName: 'codex', + primary: { + usedPercent: 12, + windowMinutes: 300, + resetsAt: new Date(1_700_000_000 * 1000).toISOString(), + }, + secondary: undefined, + credits: { + hasCredits: true, + unlimited: false, + balance: '25', + }, + }, + ]) + }) +}) + +describe('buildCodexUsageRows', () => { + test('builds Codex-like labels for primary and secondary windows', () => { + const rows = buildCodexUsageRows([ + { + limitName: 'codex', + primary: { + usedPercent: 38, + windowMinutes: 300, + resetsAt: '2026-04-02T10:00:00.000Z', + }, + secondary: { + usedPercent: 32, + windowMinutes: 10_080, + resetsAt: '2026-04-09T10:00:00.000Z', + }, + }, + { + limitName: 'code review', + primary: { + usedPercent: 0, + windowMinutes: 10_080, + resetsAt: '2026-04-09T10:00:00.000Z', + }, + }, + ]) + + expect(rows).toEqual([ + { + kind: 'window', + label: '5h limit', + usedPercent: 38, + resetsAt: '2026-04-02T10:00:00.000Z', + }, + { + kind: 'window', + label: 'Weekly limit', + usedPercent: 32, + resetsAt: '2026-04-09T10:00:00.000Z', + }, + { + kind: 'window', + label: 'Code review Weekly limit', + usedPercent: 0, + resetsAt: '2026-04-09T10:00:00.000Z', + }, + ]) + }) + + test('renders credits rows only when credits are available', () => { + const rows = buildCodexUsageRows([ + { + limitName: 'codex', + credits: { + hasCredits: true, + unlimited: false, + balance: '25.2', + }, + }, + { + limitName: 'code review', + credits: { + hasCredits: true, + unlimited: true, + }, + }, + { + limitName: 'other', + credits: { + hasCredits: true, + unlimited: false, + balance: '0', + }, + }, + ]) + + expect(rows).toEqual([ + { + kind: 'text', + label: 'Credits', + value: '25 credits', + }, + { + kind: 'text', + label: 'Code review limit', + value: '', + }, + { + kind: 'text', + label: 'Credits', + value: 'Unlimited', + }, + ]) + }) +}) + +describe('Codex usage helpers', () => { + test('formats plan labels and usage endpoint url', () => { + expect(formatCodexPlanType('team_max')).toBe('Team Max') + expect(getCodexUsageUrl()).toBe('https://chatgpt.com/backend-api/wham/usage') + expect(getCodexUsageUrl('https://chatgpt.com/backend-api/codex')).toBe( + 'https://chatgpt.com/backend-api/wham/usage', + ) + }) +}) diff --git a/src/services/api/codexUsage.ts b/src/services/api/codexUsage.ts new file mode 100644 index 00000000..06a43290 --- /dev/null +++ b/src/services/api/codexUsage.ts @@ -0,0 +1,434 @@ +import { + DEFAULT_CODEX_BASE_URL, + isCodexBaseUrl, + resolveCodexApiCredentials, + 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 + +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 { + 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 = resolveCodexApiCredentials() + if (!credentials.apiKey) { + const authHint = credentials.authPath + ? ` or place a Codex auth.json at ${credentials.authPath}` + : '' + 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 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()) +}