@cortexkit/opencode-antigravity-auth 2.0.0 → 2.0.1

package/src/tui-compiled/sidebar-state.ts

@@ -52,15 +52,20 @@ import { xdgState } from 'xdg-basedir'
 
 export const SIDEBAR_STATE_VERSION = 1 as const
 
-export type SidebarQuotaKey =
-  | 'claude'
-  | 'gemini-pro'
-  | 'gemini-flash'
-  | 'gpt-oss'
+export type SidebarQuotaKey = 'gemini' | 'non-gemini'
+
+export interface SidebarQuotaWindowEntry {
+  window: 'weekly' | '5h'
+  remainingPercent: number
+  resetAt?: number
+}
 
 export interface SidebarQuotaEntry {
+  /** Most-constrained window's remaining % (derived, for back-compat). */
   remainingPercent: number
   resetAt?: number
+  /** Per-window breakdown. Omitted in pre-windows snapshots. */
+  windows?: SidebarQuotaWindowEntry[]
 }
 
 export interface SidebarAccountState {
@@ -71,6 +76,11 @@ export interface SidebarAccountState {
   current: boolean
   cooldownUntil?: number
   quota: Partial<Record<SidebarQuotaKey, SidebarQuotaEntry>>
+  /**
+   * Captured plan tier. Absent when unknown — do NOT default to `free-tier`.
+   * `id` is the raw upstream string (e.g. `"free-tier"`); never normalised.
+   */
+  tier?: { id: string; paidId?: string; capturedAt: number }
 }
 
 export interface SidebarRoutingEntry {
@@ -294,17 +304,13 @@ function normalizeAccount(input: unknown): SidebarAccountState | null {
   const quotaRaw = record.quota
   const quota: SidebarAccountState['quota'] = {}
   if (isObject(quotaRaw)) {
-    for (const key of [
-      'claude',
-      'gemini-pro',
-      'gemini-flash',
-      'gpt-oss',
-    ] as const) {
+    for (const key of ['gemini', 'non-gemini'] as const) {
       const entry = (quotaRaw as Record<string, unknown>)[key]
       const normalized = normalizeQuota(entry)
       if (normalized) quota[key] = normalized
     }
   }
+  const tier = normalizeTier(record.tier)
   return {
     id,
     label,
@@ -313,18 +319,60 @@ function normalizeAccount(input: unknown): SidebarAccountState | null {
     current,
     cooldownUntil,
     quota,
+    ...(tier !== undefined ? { tier } : {}),
   }
 }
 
+function normalizeTier(
+  input: unknown,
+): { id: string; paidId?: string; capturedAt: number } | undefined {
+  if (!isObject(input)) return undefined
+  const record = input as Record<string, unknown>
+  const id =
+    typeof record.id === 'string' && record.id.length > 0 ? record.id : null
+  const capturedAt = toFiniteNumber(record.capturedAt)
+  if (!id || capturedAt === null) return undefined
+  const paidId =
+    typeof record.paidId === 'string' && record.paidId.length > 0
+      ? record.paidId
+      : undefined
+  return { id, ...(paidId ? { paidId } : {}), capturedAt }
+}
+
 function normalizeQuota(input: unknown): SidebarQuotaEntry | null {
   if (!isObject(input)) return null
   const record = input as Record<string, unknown>
   const remaining = toFiniteNumber(record.remainingPercent)
   if (remaining === null) return null
   const resetAt = toFiniteNumber(record.resetAt) ?? undefined
+
+  // Tolerant: deserialize windows array if present; drop malformed entries.
+  const windowsRaw = record.windows
+  let windows: SidebarQuotaEntry['windows']
+  if (Array.isArray(windowsRaw)) {
+    const parsed = windowsRaw
+      .filter(isObject)
+      .map((w) => {
+        const win = (w as Record<string, unknown>).window
+        const rp = toFiniteNumber(
+          (w as Record<string, unknown>).remainingPercent,
+        )
+        const ra = toFiniteNumber((w as Record<string, unknown>).resetAt)
+        if ((win !== 'weekly' && win !== '5h') || rp === null) return null
+        return {
+          window: win as 'weekly' | '5h',
+          remainingPercent: clampNumber(rp, 0, 100),
+          resetAt: ra ?? undefined,
+        }
+      })
+      .filter((v): v is NonNullable<typeof v> => v !== null)
+    if (parsed.length > 0) windows = parsed
+  }
+
   return {
     remainingPercent: clampNumber(remaining, 0, 100),
     resetAt,
+    windows,
   }
 }
 
@@ -441,13 +489,236 @@ export interface SidebarAccountRedactionInput {
   /** Health score in `[0, 100]`. Defaults to 100 when missing. */
   healthScore?: number
   cachedQuota?: {
-    claude?: { remainingFraction?: number; resetTime?: string }
-    'gemini-pro'?: { remainingFraction?: number; resetTime?: string }
-    'gemini-flash'?: { remainingFraction?: number; resetTime?: string }
-    'gpt-oss'?: { remainingFraction?: number; resetTime?: string }
+    gemini?: {
+      remainingFraction?: number
+      resetTime?: string
+      windows?: Array<{
+        window: 'weekly' | '5h'
+        remainingFraction: number
+        resetTime: string
+      }>
+    }
+    'non-gemini'?: {
+      remainingFraction?: number
+      resetTime?: string
+      windows?: Array<{
+        window: 'weekly' | '5h'
+        remainingFraction: number
+        resetTime: string
+      }>
+    }
+    // Legacy per-pool keys written by older versions of the plugin.
+    // Accepted here so the normalizer can map them to the current pool
+    // keys at read time without requiring a disk migration.
+    [legacyKey: string]:
+      | {
+          remainingFraction?: number
+          resetTime?: string
+          modelCount?: number
+          windows?: Array<{
+            window: 'weekly' | '5h'
+            remainingFraction: number
+            resetTime: string
+          }>
+        }
+      | undefined
+  }
+  /**
+   * Opaque identity stamp that was attached to the persisted quota snapshot.
+   * Used together with `currentQuotaAccountId` to detect a stale cache that
+   * landed on the wrong account after an index shift or token replacement.
+   * PII-safe — it is a 16-char hash, not the refresh token itself.
+   */
+  cachedQuotaAccountId?: string
+  /**
+   * Opaque identity stamp for the account that is currently at this index.
+   * The redactor drops `cachedQuota` when `cachedQuotaAccountId` is set
+   * AND does not match this value, mirroring `toCommandAccountRow` in the
+   * command-data service. Omitted in the persisted sidebar state.
+   */
+  currentQuotaAccountId?: string
+  /**
+   * Captured plan tier from `loadCodeAssist`. Absent when unknown. The `id`
+   * is the raw upstream string; `capturedAt` is epoch ms. Not PII — tier
+   * metadata survives the redaction boundary unchanged.
+   */
+  tier?: { id: string; paidId?: string; capturedAt: number }
+}
+
+/**
+ * Build a `{ id, capturedAt }` tier object from account fields, or `undefined`
+ * when either field is absent. Centralised so every producer (index.ts,
+ * background-quota-refresh.ts, command-data.ts) uses the same guard and the
+ * same shape -- the same pattern shipped as inline literals across three files
+ * and produced six missed-field bugs; one helper ends that.
+ */
+export function toCapturedTier(account: {
+  capturedTierId?: string
+  capturedPaidTierId?: string
+  capturedTierAt?: number
+}): { id: string; paidId?: string; capturedAt: number } | undefined {
+  return account.capturedTierId !== undefined &&
+    account.capturedTierAt !== undefined
+    ? {
+        id: account.capturedTierId,
+        ...(account.capturedPaidTierId !== undefined
+          ? { paidId: account.capturedPaidTierId }
+          : {}),
+        capturedAt: account.capturedTierAt,
+      }
+    : undefined
+}
+
+/**
+ * Map pre-pool legacy quota keys to the current two-pool schema at read time.
+ *
+ * Legacy mappings (empirically settled from burn tests):
+ *   `gemini-pro` + `gemini-flash`  →  `gemini`
+ *   `claude`      + `gpt-oss`       →  `non-gemini`
+ *
+ * Where multiple legacy keys collapse into one pool the MIN remainingFraction
+ * and earliest resetTime are used (most-constrained-first, matching the
+ * window-level rule). No `windows` arrays are invented for migrated entries;
+ * the single aggregate bar is the correct render for pre-window snapshots.
+ *
+ * Non-legacy keys that are already canonical (`gemini`, `non-gemini`) are
+ * carried through unchanged. The next real quota refresh overwrites any
+ * migrated snapshot with authoritative data.
+ */
+export function normalizeLegacyCachedQuota(
+  raw: SidebarAccountRedactionInput['cachedQuota'],
+): SidebarAccountRedactionInput['cachedQuota'] {
+  if (!raw) return raw
+
+  // Pool already carries current keys — fast path when no legacy keys present.
+  const hasLegacy =
+    'gemini-pro' in raw ||
+    'gemini-flash' in raw ||
+    'claude' in raw ||
+    'gpt-oss' in raw
+  if (!hasLegacy) return raw
+
+  type PoolEntry = NonNullable<
+    SidebarAccountRedactionInput['cachedQuota']
+  >['gemini']
+
+  // Pick the earlier of two ISO reset timestamps, preferring a defined
+  // value over undefined. Extracted so both branches of minFraction use
+  // the same merge rather than the previous asymmetry where the a-wins
+  // branch dropped b's possibly-earlier resetTime.
+  const earlierResetTime = (
+    a: string | undefined,
+    b: string | undefined,
+  ): string | undefined => {
+    if (!a) return b
+    if (!b) return a
+    return a < b ? a : b
+  }
+
+  const minFraction = (a: PoolEntry, b: PoolEntry): PoolEntry => {
+    if (!a) return b
+    if (!b) return a
+    const fa = a.remainingFraction ?? 1
+    const fb = b.remainingFraction ?? 1
+    const winner = fa <= fb ? a : b
+    const loser = fa <= fb ? b : a
+    // Always merge to the earliest resetTime regardless of which pool wins
+    // the fraction comparison — an earlier window expiry from the loser
+    // pool must not be silently dropped.
+    return {
+      ...winner,
+      resetTime: earlierResetTime(winner.resetTime, loser.resetTime),
+    }
+  }
+
+  const gemini: PoolEntry =
+    minFraction(
+      raw.gemini,
+      minFraction(
+        raw['gemini-pro'] as PoolEntry,
+        raw['gemini-flash'] as PoolEntry,
+      ),
+    ) ?? raw.gemini
+
+  const nonGemini: PoolEntry =
+    minFraction(
+      raw['non-gemini'],
+      minFraction(raw.claude as PoolEntry, raw['gpt-oss'] as PoolEntry),
+    ) ?? raw['non-gemini']
+
+  return {
+    ...(gemini !== undefined ? { gemini } : {}),
+    ...(nonGemini !== undefined ? { 'non-gemini': nonGemini } : {}),
   }
 }
 
+/**
+ * Project a raw cachedQuota pool entry into the sidebar-safe shape.
+ *
+ * Centralized seam — every producer (quota.ts pushSidebarQuotaSnapshot,
+ * auth-loader.ts materializer, command-data.ts writeSidebar) routes
+ * through here so the `windows` array is never dropped by an inline
+ * `{ remainingFraction, resetTime }` literal.
+ *
+ * Tolerant: returns `undefined` when the source is missing or the
+ * `remainingFraction` is not a finite number. Legacy entries without
+ * `windows` produce `{ remainingPercent, resetAt }` only — the TUI's
+ * legacy path then renders a single bar.
+ */
+export function projectQuotaPoolForSidebar(source: {
+  remainingFraction?: number
+  resetTime?: string
+  windows?: ReadonlyArray<{
+    window: 'weekly' | '5h'
+    remainingFraction: number
+    resetTime: string
+  }>
+}): SidebarQuotaEntry | undefined {
+  const fraction = source.remainingFraction
+  if (typeof fraction !== 'number' || !Number.isFinite(fraction))
+    return undefined
+  const remainingPercent = clampNumber(Math.round(fraction * 100), 0, 100)
+  let resetAt: number | undefined
+  if (typeof source.resetTime === 'string' && source.resetTime.length > 0) {
+    const parsed = Date.parse(source.resetTime)
+    if (Number.isFinite(parsed)) resetAt = parsed
+  }
+
+  const windows: SidebarQuotaEntry['windows'] = source.windows?.length
+    ? source.windows.map((w) => ({
+        window: w.window,
+        remainingPercent: clampNumber(
+          Math.round(w.remainingFraction * 100),
+          0,
+          100,
+        ),
+        resetAt:
+          typeof w.resetTime === 'string' && w.resetTime.length > 0
+            ? (() => {
+                const parsed = Date.parse(w.resetTime)
+                return Number.isFinite(parsed) ? parsed : undefined
+              })()
+            : undefined,
+      }))
+    : undefined
+
+  return { remainingPercent, resetAt, windows }
+}
+
+/**
+ * Returns `true` when an account at `index` is the active account for
+ * at least one model family. Two accounts CAN both be current — one
+ * serving claude, one serving gemini — so this must not collapse to one.
+ */
+export function isAccountCurrent(
+  index: number,
+  activeIndexByFamily: { claude: number; gemini: number },
+): boolean {
+  return (
+    index === activeIndexByFamily.claude || index === activeIndexByFamily.gemini
+  )
+}
+
 /**
  * Convert a live account snapshot into the redacted shape the TUI renders.
  * The redacted `SidebarAccountState` carries no email, refresh token, access
@@ -467,31 +738,32 @@ export function redactAccountForSidebar(
       ? source.coolingDownUntil
       : undefined
   const health = clampNumber(
-    typeof source.healthScore === 'number' ? source.healthScore : null,
+    typeof source.healthScore === 'number' ? source.healthScore : 100,
     0,
     100,
   )
 
   const quota: SidebarAccountState['quota'] = {}
-  const cached = source.cachedQuota
+  // Stamp mismatch: the persisted quota snapshot was captured for a
+  // different account than the one currently at this index. Drop the
+  // stale cache rather than rendering the wrong account's quota
+  // percentages. Mirrors `toCommandAccountRow` in command-data.
+  const staleCachedQuota =
+    typeof source.cachedQuotaAccountId === 'string' &&
+    typeof source.currentQuotaAccountId === 'string' &&
+    source.cachedQuotaAccountId !== source.currentQuotaAccountId
+  // Normalize legacy per-pool keys to the current two-pool schema before
+  // reading. This is non-destructive: the next real quota refresh will
+  // overwrite the migrated snapshot with authoritative data.
+  const cached = staleCachedQuota
+    ? undefined
+    : normalizeLegacyCachedQuota(source.cachedQuota)
   if (cached) {
-    for (const key of [
-      'claude',
-      'gemini-pro',
-      'gemini-flash',
-      'gpt-oss',
-    ] as const) {
+    for (const key of ['gemini', 'non-gemini'] as const) {
       const entry = cached[key]
       if (!entry) continue
-      const fraction = entry.remainingFraction
-      if (typeof fraction !== 'number' || !Number.isFinite(fraction)) continue
-      const remainingPercent = clampNumber(Math.round(fraction * 100), 0, 100)
-      let resetAt: number | undefined
-      if (typeof entry.resetTime === 'string' && entry.resetTime.length > 0) {
-        const parsed = Date.parse(entry.resetTime)
-        if (Number.isFinite(parsed)) resetAt = parsed
-      }
-      quota[key] = { remainingPercent, resetAt }
+      const projected = projectQuotaPoolForSidebar(entry)
+      if (projected) quota[key] = projected
     }
   }
 
@@ -503,6 +775,8 @@ export function redactAccountForSidebar(
     current,
     cooldownUntil,
     quota,
+    // Tier is plan metadata, not PII — it passes the redaction boundary.
+    ...(source.tier !== undefined ? { tier: source.tier } : {}),
   }
 }