@leviyuan/lodestar 0.2.9 → 0.3.0

package/src/sysinfo.ts

@@ -1,273 +0,0 @@
-/**
- * Lightweight host snapshot for the `hi` console panel —— CPU 负载、
- * 内存、根/家目录磁盘、以及当前用户下的 cc-* 系列 systemd 服务。
- *
- * 服务前缀约定: claude code 自己起的常驻进程统一走
- *   systemd-run --user --unit=cc-<project>-<purpose> -- <cmd>
- * (见全局 CLAUDE.md 的 background_process_safety 段)。`hi` 面板只列
- * `cc-*` 是要让 daemon 这台机器上的"AI 拉起来的活儿"一眼可见,跟
- * 系统自带 / 第三方服务区分开。
- *
- * 所有数据源都是本机文件 / 系统调用,没有网络往返:
- *   /proc/loadavg          —— 1m / 5m / 15m
- *   /proc/meminfo          —— Total / Available
- *   statfsSync(path)       —— 各挂载点容量
- *   /proc/uptime           —— monotonic seconds since boot (uptime 推算)
- *   systemctl --user show  —— cc-* 服务的状态与启动时间
- *
- * 失败可见: 任何一段读不到就把对应字段标 null,卡片层按 null 渲染
- * `_n/a_`,绝不假数据 (no_fallbacks)。
- */
-
-import { readFileSync, statfsSync, statSync } from 'node:fs'
-import { cpus, homedir } from 'node:os'
-import { log } from './log'
-
-export interface CpuInfo {
-  cores: number
-  load1: number
-  load5: number
-  load15: number
-}
-
-export interface MemInfo {
-  /** Bytes — MemTotal 来自 /proc/meminfo */
-  totalBytes: number
-  /** Bytes — MemAvailable;比 free + buffers + cached 更准 (考虑 reclaimable) */
-  availBytes: number
-  usedBytes: number
-  /** 0–100 */
-  percent: number
-}
-
-export interface DiskInfo {
-  /** 显示用的标签 ('/' 或 '$HOME') */
-  label: string
-  /** 实际查询的路径 */
-  path: string
-  totalBytes: number
-  availBytes: number
-  usedBytes: number
-  /** 0–100;按 used / total */
-  percent: number
-}
-
-export interface ServiceInfo {
-  /** 不带 .service 后缀,贴卡片用 */
-  name: string
-  /** systemd ActiveState: active | inactive | failed | activating | deactivating */
-  active: string
-  /** SubState: running | exited | dead | start | stop-sigterm | ... */
-  sub: string
-  /** 自最近一次进入 active 状态起的秒数。从未活跃过则为 null。
-   * 对 active 服务等于 "已运行 X 秒";对 inactive/failed 等于
-   * "上次跑起来到现在过了 X 秒"。 */
-  lastActiveAgoSec: number | null
-  /** 当前 ActiveState 的持续秒数 (StateChangeTimestamp → 现在)。
-   * 对 active 服务等于 lastActiveAgoSec;对 inactive 服务等于
-   * "已停了多久";对 activating/deactivating 等于"切换中多久"。 */
-  stateAgoSec: number | null
-}
-
-export interface SysInfo {
-  cpu: CpuInfo | null
-  mem: MemInfo | null
-  disks: DiskInfo[]
-  services: ServiceInfo[]
-  /** 真的查不到时(systemctl 不存在 / 拒绝)就 null;空数组表示"没有 cc-* 服务"。 */
-  servicesError: string | null
-}
-
-/** 用户态 systemd-run 服务的统一前缀。改这里要同步改 CLAUDE.md。 */
-export const SERVICE_PREFIX = 'cc-'
-
-function readCpu(): CpuInfo | null {
-  try {
-    const raw = readFileSync('/proc/loadavg', 'utf8').trim().split(/\s+/)
-    return {
-      cores: cpus().length,
-      load1: parseFloat(raw[0] ?? '0'),
-      load5: parseFloat(raw[1] ?? '0'),
-      load15: parseFloat(raw[2] ?? '0'),
-    }
-  } catch (e) {
-    log(`sysinfo: read /proc/loadavg failed: ${e}`)
-    return null
-  }
-}
-
-function readMem(): MemInfo | null {
-  try {
-    const raw = readFileSync('/proc/meminfo', 'utf8')
-    const find = (k: string): number => {
-      const m = raw.match(new RegExp(`^${k}:\\s+(\\d+)\\s*kB`, 'm'))
-      return m ? parseInt(m[1]!, 10) * 1024 : 0
-    }
-    const totalBytes = find('MemTotal')
-    const availBytes = find('MemAvailable')
-    if (!totalBytes) return null
-    const usedBytes = Math.max(0, totalBytes - availBytes)
-    return {
-      totalBytes, availBytes, usedBytes,
-      percent: Math.round((usedBytes / totalBytes) * 100),
-    }
-  } catch (e) {
-    log(`sysinfo: read /proc/meminfo failed: ${e}`)
-    return null
-  }
-}
-
-/** statfsSync 拿到的 blocks/bavail 都按 f_frsize 计算 bytes —— 注意
- * `usedBytes` 用 total - avail (不是 total - free),跟 `df` 的 Use% 列
- * 一致 (排除 root 保留块)。 */
-function readDiskFor(label: string, path: string): DiskInfo | null {
-  try {
-    const s = statfsSync(path, { bigint: false }) as {
-      bsize: number; blocks: number; bavail: number
-    }
-    const totalBytes = s.blocks * s.bsize
-    const availBytes = s.bavail * s.bsize
-    const usedBytes = Math.max(0, totalBytes - availBytes)
-    if (!totalBytes) return null
-    return {
-      label, path, totalBytes, availBytes, usedBytes,
-      percent: Math.round((usedBytes / totalBytes) * 100),
-    }
-  } catch (e) {
-    log(`sysinfo: statfs ${path} failed: ${e}`)
-    return null
-  }
-}
-
-/** 取 `/` 和 `$HOME`;如果两者属于同一文件系统(同一 device id),
- * 只返回 `/`,避免面板上挂两条一样的数据 (用户在 AskUserQuestion
- * 时知情的选择)。 */
-function readDisks(): DiskInfo[] {
-  const out: DiskInfo[] = []
-  const root = readDiskFor('/', '/')
-  if (root) out.push(root)
-  const home = homedir()
-  if (home && home !== '/') {
-    let homeOnSameFs = false
-    try {
-      const rs = statSync('/')
-      const hs = statSync(home)
-      homeOnSameFs = rs.dev === hs.dev
-    } catch {}
-    if (!homeOnSameFs) {
-      const homeDisk = readDiskFor('$HOME', home)
-      if (homeDisk) out.push(homeDisk)
-    }
-  }
-  return out
-}
-
-/** /proc/uptime 第一个数是 monotonic 自启动以来的秒数。 */
-function readMonotonicSec(): number | null {
-  try {
-    const raw = readFileSync('/proc/uptime', 'utf8').trim().split(/\s+/)
-    return parseFloat(raw[0] ?? '0')
-  } catch {
-    return null
-  }
-}
-
-/** 用 Bun.spawn 跑 `systemctl --user`,合并 stdout 并返回 trim 后的字符串。
- * 超时(默认 2s)或非零退出码都返回 null,让调用方走错误分支。 */
-async function runSystemctl(args: string[], timeoutMs = 2000): Promise<string | null> {
-  try {
-    const proc = Bun.spawn(['systemctl', '--user', ...args], {
-      stdout: 'pipe', stderr: 'pipe',
-    })
-    const timer = setTimeout(() => {
-      try { proc.kill('SIGTERM') } catch {}
-    }, timeoutMs)
-    const text = await new Response(proc.stdout).text()
-    const code = await proc.exited
-    clearTimeout(timer)
-    if (code !== 0) return null
-    return text
-  } catch (e) {
-    log(`sysinfo: systemctl ${args.join(' ')} failed: ${e}`)
-    return null
-  }
-}
-
-/** 列 `${SERVICE_PREFIX}*` 服务并解析:第 1 步用 list-units 拿名字,
- * 第 2 步用单次 show -p 拿状态 + ActiveEnterTimestampMonotonic。两步
- * 都是本地调用,加起来 < 100ms。 */
-async function readServices(): Promise<{ services: ServiceInfo[]; error: string | null }> {
-  // list-units 输出每行: "<unit> <load> <active> <sub> <description>"。
-  // --all 把 inactive 也列出来 (用户停过的服务也值得在面板看到)。
-  // 加 --plain --no-legend 关掉表格修饰和 footer,方便机器解析。
-  const listOut = await runSystemctl([
-    'list-units', '--type=service', '--all', '--no-legend', '--plain', `${SERVICE_PREFIX}*`,
-  ])
-  if (listOut === null) {
-    return { services: [], error: 'systemctl 不可用' }
-  }
-  const lines = listOut.split('\n').map(l => l.trim()).filter(l => l.length > 0)
-  if (lines.length === 0) return { services: [], error: null }
-
-  const names: string[] = []
-  for (const line of lines) {
-    // 第一列是 unit 全名,可能带前缀●;.service 后缀去掉。
-    const cols = line.replace(/^●\s*/, '').split(/\s+/)
-    const unit = cols[0]
-    if (!unit) continue
-    if (!unit.startsWith(SERVICE_PREFIX)) continue
-    if (!unit.endsWith('.service')) continue
-    names.push(unit)
-  }
-  if (names.length === 0) return { services: [], error: null }
-
-  // 一次性 show 多个 unit:每个 unit 输出一段属性,段之间空行分隔。
-  // ActiveEnter = 最近一次进入 active 的时刻 (即使现在已 inactive 也保留);
-  // StateChange = 当前 ActiveState 进入时刻。两者对 active 服务相同,
-  // 对 inactive 服务分别是"上次活跃"与"停了多久"。
-  const showOut = await runSystemctl([
-    'show', ...names,
-    '-p', 'Id',
-    '-p', 'ActiveState',
-    '-p', 'SubState',
-    '-p', 'ActiveEnterTimestampMonotonic',
-    '-p', 'StateChangeTimestampMonotonic',
-  ])
-  if (showOut === null) return { services: [], error: 'systemctl show 失败' }
-
-  const monotonicNowSec = readMonotonicSec()
-  const blocks = showOut.split(/\n\s*\n/)
-  const services: ServiceInfo[] = []
-  const ageFrom = (microStr: string | undefined): number | null => {
-    const micro = parseInt(microStr ?? '0', 10)
-    if (micro <= 0 || monotonicNowSec === null) return null
-    return Math.max(0, monotonicNowSec - micro / 1_000_000)
-  }
-  for (const block of blocks) {
-    const props: Record<string, string> = {}
-    for (const line of block.split('\n')) {
-      const eq = line.indexOf('=')
-      if (eq <= 0) continue
-      props[line.slice(0, eq)] = line.slice(eq + 1)
-    }
-    const id = props.Id ?? ''
-    if (!id.startsWith(SERVICE_PREFIX) || !id.endsWith('.service')) continue
-    services.push({
-      name: id.replace(/\.service$/, ''),
-      active: props.ActiveState ?? 'unknown',
-      sub: props.SubState ?? '',
-      lastActiveAgoSec: ageFrom(props.ActiveEnterTimestampMonotonic),
-      stateAgoSec: ageFrom(props.StateChangeTimestampMonotonic),
-    })
-  }
-  services.sort((a, b) => a.name.localeCompare(b.name))
-  return { services, error: null }
-}
-
-export async function readSysInfo(): Promise<SysInfo> {
-  const cpu = readCpu()
-  const mem = readMem()
-  const disks = readDisks()
-  const { services, error } = await readServices()
-  return { cpu, mem, disks, services, servicesError: error }
-}

package/src/usage.ts

@@ -1,327 +0,0 @@
-/**
- * Subscription usage snapshot for the `hi` console panel.
- *
- * Source: Anthropic 官方 OAuth Usage API —— `GET /api/oauth/usage`.
- * 不再依赖外部 ccusage CLI。
- *
- * 凭据来源: `~/.claude/.credentials.json`(Linux 服务器,无 macOS
- * Keychain 分支)。结构由 Claude Code 写入,我们读 `claudeAiOauth`
- * 字段拿 access_token / refresh_token / expires_at / subscriptionType /
- * rateLimitTier。
- *
- * access_token 过期时,用 refresh_token 调 platform.claude.com
- * `/v1/oauth/token` 刷新,刷新成功后原子写回凭据文件
- * (tmp + rename),保证多进程并发安全。
- *
- * 失败可见 (no_fallbacks):
- *   - 凭据缺失      → state='no_credentials'
- *   - 刷新也失败    → state='auth_failed'
- *   - API 返回 429  → state='rate_limited' (+ resetsAt 可选)
- *   - 其它网络异常  → state='network'
- *
- * 卡片渲染层 (`cards.consoleUsageContent`) 按 state 分别显示具体原因,
- * 不静默回退到旧值,不伪造百分比。
- *
- * Lodestar 启动后,每次 `hi` 弹板都会拉一次;CACHE_TTL_MS 内的重复
- * 调用共享同一份快照,不打 API。in-flight 去重保证并发的多个
- * 群同时唤出控制台时只触发一次后台请求。
- *
- * Stale fallback (照 omchud HUD 规则): 单独记最后一次成功拉到的
- * `state:'ok'` 快照,本次拉取失败 (network/rate_limited/auth_failed)
- * 且距上次成功 <= MAX_STALE_MS (15 分钟) 时,返回上次的 ok 快照并打
- * `stale:true` 标签,卡片层加 "缓存 Xm 前" 提示。这是 no_fallbacks
- * 规则的显式例外 —— 用户明确要求订阅额度面板用缓存兜底,因为短暂
- * 网络抖动里把面板上的数字抹成红色"拉取失败"信息密度反而更低。
- *
- * 429 指数退避: 收到 rate_limited 时增加 rateLimitedCount,下次允许
- * 实拉的时间设为 now + CACHE_TTL_MS * 2^(count-1),封顶 5 分钟。
- * 退避窗口内的 readUsage 直接走 stale fallback,不打 API。任何非 429
- * 的响应 (ok / network / auth_failed) 都会重置计数器。
- *
- * 参考实现: oh-my-claudecode HUD `src/hud/usage-api.ts`。这里只保留
- * Lodestar 用得到的最小子集 —— 不处理 keychain、不处理第三方网关
- * (z.ai / MiniMax)、不处理 enterprise 货币换算、不做多文件 cache 与
- * 文件锁。
- */
-
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-import { log } from './log'
-
-const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
-const TOKEN_REFRESH_URL = 'https://platform.claude.com/v1/oauth/token'
-const OAUTH_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e'
-const API_TIMEOUT_MS = 10_000
-const CACHE_TTL_MS = 60_000
-/** 失败时回退到上次成功快照的最大年龄。超过此值就不再用缓存兜底,
- * 显示真实失败状态 —— 跟 omchud HUD 的 MAX_STALE_DATA_MS 对齐。 */
-const MAX_STALE_MS = 15 * 60 * 1000
-/** 429 退避封顶,跟 omchud HUD 的 MAX_RATE_LIMITED_BACKOFF_MS 对齐。 */
-const RATE_LIMITED_MAX_BACKOFF_MS = 5 * 60 * 1000
-
-function credentialsPath(): string {
-  return join(homedir(), '.claude', '.credentials.json')
-}
-
-interface OAuthCredentials {
-  accessToken: string
-  refreshToken?: string
-  expiresAt?: number
-  subscriptionType?: string
-  rateLimitTier?: string
-}
-
-export interface UsageWindow {
-  /** 0-100, Anthropic 直接返回的 utilization 真实值 */
-  percent: number
-  /** 这个窗口何时重置;ISO 解析失败则 null */
-  resetsAt: Date | null
-}
-
-export type UsageSnapshot =
-  | { state: 'no_credentials' }
-  | { state: 'auth_failed' }
-  | { state: 'rate_limited' }
-  | { state: 'network'; reason?: string }
-  | {
-      state: 'ok'
-      subscriptionType?: string
-      fiveHour: UsageWindow | null
-      weekly: UsageWindow | null
-      fetchedAt: number
-      /** true 时本快照不是这次实拉的,而是 lastOk 兜底回来的旧数据。
-       * 卡片层据此显示 "缓存" 标记 + 重置时间加 `~` 前缀。 */
-      stale?: boolean
-    }
-
-type UsageSnapshotOk = Extract<UsageSnapshot, { state: 'ok' }>
-
-let cache: { data: UsageSnapshot; at: number } | null = null
-/** 最近一次 state:'ok' 的快照,用于失败时兜底。和 cache 分开存:
- * cache 是短时去重 (60s),lastOk 是长尾兜底 (15min)。 */
-let lastOk: { snapshot: UsageSnapshotOk; at: number } | null = null
-let inFlight: Promise<UsageSnapshot> | null = null
-/** 连续 429 计数,用于指数退避;遇到任何非 429 响应就重置为 0。 */
-let rateLimitedCount = 0
-/** 在这个时间戳之前不打 API,直接走 stale fallback。 */
-let rateLimitedUntil = 0
-
-function rateLimitedBackoffMs(count: number): number {
-  return Math.min(
-    CACHE_TTL_MS * Math.pow(2, Math.max(0, count - 1)),
-    RATE_LIMITED_MAX_BACKOFF_MS,
-  )
-}
-
-function readCredentials(): OAuthCredentials | null {
-  const path = credentialsPath()
-  if (!existsSync(path)) return null
-  try {
-    const raw = readFileSync(path, 'utf8')
-    const parsed = JSON.parse(raw)
-    const creds = parsed.claudeAiOauth ?? parsed
-    if (!creds?.accessToken) return null
-    return {
-      accessToken: creds.accessToken,
-      refreshToken: creds.refreshToken,
-      expiresAt: creds.expiresAt,
-      subscriptionType: creds.subscriptionType,
-      rateLimitTier: creds.rateLimitTier,
-    }
-  } catch (e) {
-    log(`usage: read credentials failed: ${e}`)
-    return null
-  }
-}
-
-/** 把刷新后的 access_token / refresh_token / expires_at 原子写回原文件,
- * 保留其它字段(scopes、subscriptionType、organizationUuid 等)。
- * 走 tmp + rename 防止半写状态被读到。 */
-function writeBackCredentials(updated: OAuthCredentials): void {
-  const path = credentialsPath()
-  if (!existsSync(path)) return
-  try {
-    const parsed = JSON.parse(readFileSync(path, 'utf8'))
-    const target = parsed.claudeAiOauth ?? parsed
-    target.accessToken = updated.accessToken
-    if (updated.refreshToken) target.refreshToken = updated.refreshToken
-    if (updated.expiresAt != null) target.expiresAt = updated.expiresAt
-    const tmp = `${path}.tmp.${process.pid}`
-    try {
-      writeFileSync(tmp, JSON.stringify(parsed, null, 2), { mode: 0o600 })
-      renameSync(tmp, path)
-    } catch (e) {
-      try { if (existsSync(tmp)) unlinkSync(tmp) } catch {}
-      throw e
-    }
-  } catch (e) {
-    log(`usage: writeBackCredentials failed: ${e}`)
-  }
-}
-
-function isExpired(creds: OAuthCredentials): boolean {
-  return creds.expiresAt != null && creds.expiresAt <= Date.now()
-}
-
-async function refreshAccessToken(refreshToken: string): Promise<OAuthCredentials | null> {
-  const body = new URLSearchParams({
-    grant_type: 'refresh_token',
-    refresh_token: refreshToken,
-    client_id: OAUTH_CLIENT_ID,
-  }).toString()
-  const ctrl = new AbortController()
-  const timer = setTimeout(() => ctrl.abort(), API_TIMEOUT_MS)
-  try {
-    const res = await fetch(TOKEN_REFRESH_URL, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body,
-      signal: ctrl.signal,
-    })
-    if (res.status !== 200) {
-      log(`usage: token refresh HTTP ${res.status}`)
-      return null
-    }
-    const json = await res.json() as any
-    if (!json?.access_token) return null
-    return {
-      accessToken: json.access_token,
-      refreshToken: json.refresh_token ?? refreshToken,
-      expiresAt: json.expires_in
-        ? Date.now() + json.expires_in * 1000
-        : json.expires_at,
-    }
-  } catch (e) {
-    log(`usage: token refresh threw: ${e}`)
-    return null
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-interface UsageApiResponse {
-  five_hour?: { utilization?: number; resets_at?: string }
-  seven_day?: { utilization?: number; resets_at?: string }
-}
-
-function parseDate(s: string | undefined): Date | null {
-  if (!s) return null
-  const d = new Date(s)
-  return isNaN(d.getTime()) ? null : d
-}
-
-function clampPct(v: number | undefined): number {
-  if (v == null || !isFinite(v)) return 0
-  return Math.max(0, Math.min(100, v))
-}
-
-interface FetchResult {
-  data: UsageApiResponse | null
-  /** 失败原因:undefined = 成功;其它字符串是分类错误。 */
-  reason?: 'rate_limited' | 'network'
-  detail?: string
-}
-
-async function fetchUsageFromApi(accessToken: string): Promise<FetchResult> {
-  const ctrl = new AbortController()
-  const timer = setTimeout(() => ctrl.abort(), API_TIMEOUT_MS)
-  try {
-    const res = await fetch(USAGE_URL, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-beta': 'oauth-2025-04-20',
-        'Content-Type': 'application/json',
-      },
-      signal: ctrl.signal,
-    })
-    if (res.status === 200) {
-      const data = await res.json() as UsageApiResponse
-      return { data }
-    }
-    if (res.status === 429) return { data: null, reason: 'rate_limited' }
-    return { data: null, reason: 'network', detail: `HTTP ${res.status}` }
-  } catch (e: any) {
-    return { data: null, reason: 'network', detail: e?.message ?? String(e) }
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-async function fetchUsage(): Promise<UsageSnapshot> {
-  let creds = readCredentials()
-  if (!creds) return { state: 'no_credentials' }
-
-  if (isExpired(creds)) {
-    if (!creds.refreshToken) return { state: 'auth_failed' }
-    const refreshed = await refreshAccessToken(creds.refreshToken)
-    if (!refreshed) return { state: 'auth_failed' }
-    creds = { ...creds, ...refreshed }
-    writeBackCredentials(creds)
-  }
-
-  const result = await fetchUsageFromApi(creds.accessToken)
-  if (result.reason === 'rate_limited') return { state: 'rate_limited' }
-  if (result.reason === 'network' || !result.data) return { state: 'network', reason: result.detail }
-
-  const data = result.data
-  const fiveHour = data.five_hour?.utilization != null
-    ? { percent: clampPct(data.five_hour.utilization), resetsAt: parseDate(data.five_hour.resets_at) }
-    : null
-  const weekly = data.seven_day?.utilization != null
-    ? { percent: clampPct(data.seven_day.utilization), resetsAt: parseDate(data.seven_day.resets_at) }
-    : null
-
-  return {
-    state: 'ok',
-    subscriptionType: creds.subscriptionType,
-    fiveHour,
-    weekly,
-    fetchedAt: Date.now(),
-  }
-}
-
-/** 失败快照 → 如果 MAX_STALE_MS 内还有 lastOk,就返回 lastOk 的副本
- * (打 stale 标);否则透传失败快照。state:'ok' 走 fast path 原样返回。 */
-function withStaleFallback(snapshot: UsageSnapshot): UsageSnapshot {
-  if (snapshot.state === 'ok') return snapshot
-  if (lastOk && Date.now() - lastOk.at < MAX_STALE_MS) {
-    return { ...lastOk.snapshot, stale: true }
-  }
-  return snapshot
-}
-
-/** 返回订阅额度快照。CACHE_TTL_MS 内的重复调用读缓存;并发请求去重为
- * 单次后台 fetch。拉取失败但 lastOk 仍在 MAX_STALE_MS 内时,回退到
- * lastOk 并打 stale 标。连续 429 走指数退避,退避窗口内不打 API。
- * 永不抛出 —— 失败状态由 `state` 字段表达,卡片层按 state 分支渲染。 */
-export async function readUsage(): Promise<UsageSnapshot> {
-  // 429 退避窗口内不打 API。cache 里可能存的就是 rate_limited 失败态,
-  // withStaleFallback 会自动用 lastOk 顶上(15min 内)。
-  if (Date.now() < rateLimitedUntil) {
-    return withStaleFallback(cache?.data ?? { state: 'rate_limited' })
-  }
-  if (cache && Date.now() - cache.at < CACHE_TTL_MS) return withStaleFallback(cache.data)
-  if (inFlight) return inFlight
-  inFlight = fetchUsage()
-    .then(d => {
-      cache = { data: d, at: Date.now() }
-      if (d.state === 'ok') lastOk = { snapshot: d, at: Date.now() }
-      if (d.state === 'rate_limited') {
-        rateLimitedCount += 1
-        rateLimitedUntil = Date.now() + rateLimitedBackoffMs(rateLimitedCount)
-      } else {
-        rateLimitedCount = 0
-        rateLimitedUntil = 0
-      }
-      inFlight = null
-      return withStaleFallback(d)
-    })
-    .catch(e => {
-      log(`usage: fetchUsage threw: ${e}`)
-      inFlight = null
-      return withStaleFallback({ state: 'network', reason: String(e) })
-    })
-  return inFlight
-}