@cortexkit/opencode-antigravity-auth 2.2.0 → 3.0.0

package/src/tui-ga-compiled/shared/8ae1927e5910ea81-sidebar-projection.js

@@ -0,0 +1,112 @@
+import { quotaReadingParts } from "./98cc0c186c46c42d-quota-presentation.js";
+export const QUOTA_POOL_LABELS = {
+  gemini: "Gm",
+  "non-gemini": "NG"
+};
+const POOL_ORDER = ["gemini", "non-gemini"];
+function clamp(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.min(100, Math.max(0, value));
+}
+export function remainingTone(remaining) {
+  if (remaining === null)
+    return "muted";
+  if (remaining <= 10)
+    return "err";
+  if (remaining <= 30)
+    return "warn";
+  return "ok";
+}
+export function formatResetIn(resetAt, now) {
+  if (!resetAt)
+    return "";
+  const ms = resetAt - now;
+  if (ms <= 0)
+    return "now";
+  const mins = Math.floor(ms / 60000);
+  if (mins < 60)
+    return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) {
+    const rm = mins % 60;
+    return rm > 0 ? `${hrs}h${rm}m` : `${hrs}h`;
+  }
+  const days = Math.floor(hrs / 24), rh = hrs % 24;
+  return rh > 0 ? `${days}d${rh}h` : `${days}d`;
+}
+export function formatWait(ms) {
+  const seconds = Math.ceil(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60), remaining = seconds % 60;
+  return remaining > 0 ? `${minutes}m ${remaining}s` : `${minutes}m`;
+}
+function quotaRows(account, now) {
+  const rows = [];
+  for (const key of POOL_ORDER) {
+    const entry = account.quota[key], label = QUOTA_POOL_LABELS[key];
+    if (!entry) {
+      rows.push({
+        label,
+        remaining: null,
+        figure: quotaReadingParts(label, void 0, now).figure,
+        tone: "muted",
+        reset: ""
+      });
+      continue;
+    }
+    const windows = entry.windows ?? [];
+    if (windows.length === 0) {
+      const parts = quotaReadingParts(label, entry, now);
+      rows.push({
+        label,
+        remaining: parts.remaining,
+        figure: parts.figure,
+        tone: remainingTone(parts.remaining),
+        reset: parts.detail
+      });
+      continue;
+    }
+    for (const window of windows) {
+      const parts = quotaReadingParts(label, window, now);
+      rows.push({
+        label: `${label} ${parts.name}`,
+        remaining: parts.remaining,
+        figure: parts.figure,
+        tone: remainingTone(parts.remaining),
+        reset: parts.detail
+      });
+    }
+  }
+  return rows;
+}
+export function projectAccount(account, now) {
+  const cooling = typeof account.cooldownUntil === "number" && account.cooldownUntil > now, status = !account.enabled ? "off" : cooling ? "cooling" : account.current ? "active" : "idle", statusTone = status === "off" ? "muted" : status === "cooling" ? "warn" : status === "active" ? "ok" : "muted", base = `health ${Math.round(clamp(account.health))}`, health = cooling ? `${base} \xB7 cooling ${formatWait(account.cooldownUntil - now)}` : base;
+  return {
+    id: account.id,
+    label: account.label,
+    status,
+    statusTone,
+    quota: quotaRows(account, now),
+    health
+  };
+}
+export function projectSidebar(input) {
+  const accounts = input.accounts.map((account) => projectAccount(account, input.now));
+  let route = null;
+  if (input.route)
+    route = [
+      input.accounts.find((account) => account.id === input.route?.accountId)?.label ?? "unknown account",
+      input.route.modelFamily,
+      input.route.headerStyle
+    ].join(" \xB7 ");
+  const notices = [];
+  if (input.status.quotaBackoffUntil !== null && input.status.quotaBackoffUntil > input.now)
+    notices.push(`quota checks paused ${formatWait(input.status.quotaBackoffUntil - input.now)}`);
+  if (input.status.checkedAt === null)
+    notices.push("quota not checked yet");
+  if (accounts.length === 0)
+    notices.push("no accounts");
+  return { accounts, route, notices };
+}

package/src/tui-ga-compiled/shared/98cc0c186c46c42d-quota-presentation.js

@@ -0,0 +1,42 @@
+import {
+  formatQuota,
+  NO_QUOTA_READING,
+  quotaTextParts,
+  quotaWindowName
+} from "./bf17cbee28e58197-index.js";
+
+export { NO_QUOTA_READING };
+function projectReading(label, reading) {
+  const checkedAt = reading?.checkedAt;
+  if (!reading || typeof checkedAt !== "number" || !Number.isFinite(checkedAt) || checkedAt < 0 || !Number.isFinite(reading.remainingPercent))
+    return;
+  return { scope: "all", limits: [{
+    scope: reading.window ? "all" : label,
+    label,
+    kind: "reading",
+    checkedAt,
+    remainingPercent: Math.max(0, Math.min(100, reading.remainingPercent)),
+    ...reading.window ? { windowMinutes: reading.window === "weekly" ? 10080 : 300 } : {},
+    ...typeof reading.resetAt === "number" && Number.isFinite(reading.resetAt) && Math.abs(reading.resetAt) <= 8640000000000000 ? { resetsAt: new Date(reading.resetAt).toISOString() } : {}
+  }], checkedAt };
+}
+export function formatQuotaReading(label, reading, now) {
+  return formatQuota(projectReading(label, reading), { now });
+}
+export function quotaReadingParts(label, reading, now) {
+  const projected = projectReading(label, reading), limit = projected?.limits[0];
+  if (!limit)
+    return {
+      name: label,
+      figure: NO_QUOTA_READING,
+      detail: "",
+      remaining: null
+    };
+  const full = quotaTextParts(projected, { now }), compact = quotaTextParts(projected, { now, form: "compact" }), name = quotaWindowName(limit), first = compact[0] ?? "", figure = first.startsWith(`${name} `) ? first.slice(name.length + 1) : first, reset = (full[0] ?? "").slice(first.length).replace(/^, /, "");
+  return {
+    name,
+    figure,
+    detail: [reset, ...full.slice(1)].filter(Boolean).join(" \xB7 "),
+    remaining: limit.remainingPercent ?? null
+  };
+}

package/src/tui-ga-compiled/shared/aef2402f8fc342f0-format.js

@@ -0,0 +1,138 @@
+// The one quota wording every surface shows: the command menu's dialogs on
+// OpenCode and Pi, the terminal auth menu, and the plugins' sidebars. Each of
+// them calls `formatQuota` (or `quotaTextParts` for one line per window), so
+// the wording cannot drift between plugins or between a dialog and a sidebar.
+//
+// The rules: a window is named by its length (`5h`, `7d`), or, for a window
+// that binds only one model family, by the label the plugin stored it under.
+// Every figure is "% left". A window the provider did not report (an absence
+// record or a retirement tombstone) is left out rather than written as "not
+// reported". A reset is a short time from now (`resets 2h`). A reading older
+// than fifteen minutes says how old it is (`checked 3h ago`).
+//
+// Like the rest of this module it reads no clock: `now` is a parameter.
+import { ALL_SCOPE } from "./77138df80c7ae006-map.js";
+/** A reading older than this is marked with its age. */
+export const QUOTA_STALE_AFTER_MS = 15 * 60_000;
+/** What `formatQuota` returns when there is no reading at all. */
+export const NO_QUOTA_READING = 'no quota reading yet';
+/**
+ * What `formatQuota` returns when the provider answered but reported no
+ * limit for any window (every window is an absence record or a tombstone).
+ */
+export const NO_LIMITS_REPORTED = 'no limits reported';
+/**
+ * A length or a time span in its largest whole-ish unit: `45m`, `5h`, `3d`.
+ * Spans under an hour are minutes, under a day hours, otherwise days, each
+ * rounded to the nearest unit and never shown as zero.
+ */
+function shortSpan(ms) {
+    const minutes = Math.max(1, Math.round(ms / 60_000));
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.max(1, Math.round(minutes / 1440))}d`;
+}
+/** A stored window length in minutes as its exact name: `5h`, `7d`, `90m`. */
+function lengthName(minutes) {
+    if (minutes % 1440 === 0)
+        return `${minutes / 1440}d`;
+    if (minutes % 60 === 0)
+        return `${minutes / 60}h`;
+    return `${minutes}m`;
+}
+/**
+ * The name a window is shown under. A general window (scope `all`) is named
+ * by its stored length; a model-scoped window keeps the label the plugin
+ * stored it under, which already names the model (`seven_day_opus`). A
+ * general window stored without a length (a snapshot from before lengths
+ * were recorded) falls back to its label.
+ */
+export function quotaWindowName(limit) {
+    if (limit.scope !== ALL_SCOPE || limit.windowMinutes === undefined)
+        return limit.label;
+    return lengthName(limit.windowMinutes);
+}
+function percentLeft(remaining) {
+    return `${Math.round(Math.min(100, Math.max(0, remaining)))}% left`;
+}
+function resetText(resetsAt, now) {
+    if (resetsAt === undefined)
+        return '';
+    const at = Date.parse(resetsAt);
+    // A reset already passed says nothing about the future; leave it out.
+    if (!Number.isFinite(at) || at <= now)
+        return '';
+    return `, resets ${shortSpan(at - now)}`;
+}
+/** Shortest window first, so `5h` reads before `7d`; unknown lengths last. */
+function displayOrder(left, right) {
+    const l = left.windowMinutes;
+    const r = right.windowMinutes;
+    if (l !== undefined && r !== undefined && l !== r)
+        return l - r;
+    if ((l === undefined) !== (r === undefined))
+        return l === undefined ? 1 : -1;
+    if (left.scope !== right.scope) {
+        if (left.scope === ALL_SCOPE)
+            return -1;
+        if (right.scope === ALL_SCOPE)
+            return 1;
+        return left.scope < right.scope ? -1 : 1;
+    }
+    return left.label < right.label ? -1 : left.label > right.label ? 1 : 0;
+}
+/**
+ * The pieces of a quota text, in order: one per reported window
+ * (`5h 58% left, resets 2h`), then the credit budget when there is one, then
+ * `checked 3h ago` when the oldest piece shown is stale. Empty when nothing
+ * was reported; `formatQuota` turns that into a sentence. A caller printing
+ * one line per window (the terminal auth menu) uses these directly.
+ */
+export function quotaTextParts(quota, options) {
+    if (!quota)
+        return [];
+    const { now } = options;
+    const full = (options.form ?? 'full') === 'full';
+    const parts = [];
+    const times = [];
+    const readings = quota.limits
+        .filter((limit) => limit.kind === 'reading' && limit.remainingPercent !== undefined)
+        .sort(displayOrder);
+    for (const limit of readings) {
+        times.push(limit.checkedAt);
+        parts.push(`${quotaWindowName(limit)} ${percentLeft(limit.remainingPercent ?? 0)}${full ? resetText(limit.resetsAt, now) : ''}`);
+    }
+    const budget = quota.budget;
+    if (budget) {
+        times.push(budget.checkedAt);
+        const figure = budget.reached
+            ? 'credits spent'
+            : budget.remainingPercent !== undefined
+                ? `credits ${percentLeft(budget.remainingPercent)}`
+                : 'credits available';
+        parts.push(`${figure}${full ? resetText(budget.resetsAt, now) : ''}`);
+    }
+    if (times.length > 0) {
+        const age = now - Math.min(...times);
+        if (age > (options.staleAfterMs ?? QUOTA_STALE_AFTER_MS))
+            parts.push(`checked ${shortSpan(age)} ago`);
+    }
+    return parts;
+}
+/**
+ * A row's quota as one line: `5h 58% left · 7d 90% left` in the compact
+ * form, with `, resets 2h` after each window in the full form. With nothing
+ * reported it is `NO_QUOTA_READING`, or `NO_LIMITS_REPORTED` when the
+ * provider answered without a limit for any window.
+ */
+export function formatQuota(quota, options) {
+    const parts = quotaTextParts(quota, options);
+    if (parts.length > 0)
+        return parts.join(' · ');
+    return quota && quota.limits.length > 0
+        ? NO_LIMITS_REPORTED
+        : NO_QUOTA_READING;
+}

package/src/tui-ga-compiled/shared/bf17cbee28e58197-index.js

@@ -0,0 +1,5 @@
+export { quotaCodec } from "./ca21dc417b36dc5d-codec.js";
+export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, } from "./aef2402f8fc342f0-format.js";
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, emptyQuotaMap, isQuotaMap, } from "./77138df80c7ae006-map.js";
+export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from "./ecc214300932dfb6-merge.js";
+export { budgetExhaustedResetAt, futureResetAt, projectQuota, readsExhausted, } from "./1ff34afa7c42d196-projection.js";

package/src/tui-ga-compiled/shared/ca21dc417b36dc5d-codec.js

@@ -0,0 +1,12 @@
+import { isQuotaMap } from "./77138df80c7ae006-map.js";
+import { mergeQuotaObservation } from "./ecc214300932dfb6-merge.js";
+/**
+ * The quota codec the account-pool store (the `/store` subpath) takes when it
+ * is opened: `validate` checks a stored per-row quota map and `merge` applies
+ * an observation to one, so the store persists the map without interpreting
+ * it.
+ */
+export const quotaCodec = Object.freeze({
+    validate: isQuotaMap,
+    merge: mergeQuotaObservation,
+});

package/src/tui-ga-compiled/shared/ecc214300932dfb6-merge.js

@@ -0,0 +1,162 @@
+// Merging one observation into a stored quota map.
+//
+// One freshness rule applies everywhere: an observation applies to a key when
+// it is not older than what the key holds, so an equal time applies and the
+// observation applied last wins, as openai-auth's `freshestWindow` does.
+//
+// An observation carries readings plus a coverage list: the (scope, label)
+// pairs it speaks for with authority. Every reading is implicitly covered. A
+// covered pair the observation carries no reading for is reported as having
+// no limit: an existing reading becomes a retirement tombstone, and a key with
+// no entry gets an absence record. A pair outside the coverage is never
+// touched, so a header-shaped partial observation (which covers only what it
+// carries) cannot erase a family limit or the budget.
+import { ALL_SCOPE, entryTime, isQuotaMap, limitKey, } from "./77138df80c7ae006-map.js";
+/** Thrown by `mergeQuotaObservation` when either argument is malformed. */
+export class QuotaCodecError extends TypeError {
+    constructor(message) {
+        super(message);
+        this.name = 'QuotaCodecError';
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isScope(value) {
+    return value === undefined || (typeof value === 'string' && value !== '');
+}
+function isLabel(value) {
+    return typeof value === 'string' && value !== '';
+}
+function optionalFinite(record, key) {
+    return record[key] === undefined || isFiniteNumber(record[key]);
+}
+function optionalString(record, key) {
+    return record[key] === undefined || typeof record[key] === 'string';
+}
+function isObservedReading(value) {
+    return (isRecord(value) &&
+        isScope(value.scope) &&
+        isLabel(value.label) &&
+        isFiniteNumber(value.usedPercent) &&
+        optionalString(value, 'resetsAt') &&
+        (value.windowMinutes === undefined ||
+            (isFiniteNumber(value.windowMinutes) && value.windowMinutes > 0)));
+}
+function isObservedPair(value) {
+    return isRecord(value) && isScope(value.scope) && isLabel(value.label);
+}
+function isObservedBudget(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === 'cleared')
+        return true;
+    return (value.kind === 'reading' &&
+        typeof value.reached === 'boolean' &&
+        optionalFinite(value, 'remainingPercent') &&
+        optionalFinite(value, 'usedPercent') &&
+        optionalString(value, 'resetsAt') &&
+        optionalFinite(value, 'limit') &&
+        optionalFinite(value, 'used') &&
+        optionalFinite(value, 'remaining') &&
+        optionalString(value, 'unit'));
+}
+/** True when `value` is a well-formed observation; a pair read twice is not. */
+export function isQuotaObservation(value) {
+    if (!isRecord(value) || !isFiniteNumber(value.checkedAt))
+        return false;
+    const readings = value.readings ?? [];
+    const coverage = value.coverage ?? [];
+    if (!Array.isArray(readings) || !Array.isArray(coverage))
+        return false;
+    const read = new Set();
+    for (const reading of readings) {
+        if (!isObservedReading(reading))
+            return false;
+        const key = limitKey(reading.scope ?? ALL_SCOPE, reading.label);
+        if (read.has(key))
+            return false;
+        read.add(key);
+    }
+    if (!coverage.every(isObservedPair))
+        return false;
+    return value.budget === undefined || isObservedBudget(value.budget);
+}
+function compareEntries(left, right) {
+    if (left.scope !== right.scope)
+        return left.scope < right.scope ? -1 : 1;
+    if (left.label !== right.label)
+        return left.label < right.label ? -1 : 1;
+    return 0;
+}
+function mergeBudget(stored, observed, checkedAt) {
+    if (observed === undefined)
+        return stored;
+    if (stored !== undefined && checkedAt < stored.checkedAt)
+        return stored;
+    return { ...observed, checkedAt };
+}
+/**
+ * Applies `observation` to `stored` (undefined for a row with no map yet) and
+ * returns the new map. Pure: neither argument is modified. Throws
+ * `QuotaCodecError` when either argument is malformed, so a store refuses the
+ * write rather than persisting a map it could not read back.
+ */
+export function mergeQuotaObservation(stored, observation) {
+    if (stored !== undefined && !isQuotaMap(stored)) {
+        throw new QuotaCodecError('stored quota map is malformed');
+    }
+    if (!isQuotaObservation(observation)) {
+        throw new QuotaCodecError('quota observation is malformed');
+    }
+    const base = stored ?? { limits: [] };
+    const at = observation.checkedAt;
+    const entries = new Map();
+    for (const entry of base.limits) {
+        entries.set(limitKey(entry.scope, entry.label), entry);
+    }
+    const applies = (key) => {
+        const existing = entries.get(key);
+        return existing === undefined || at >= entryTime(existing);
+    };
+    const carried = new Set();
+    for (const reading of observation.readings ?? []) {
+        const scope = reading.scope ?? ALL_SCOPE;
+        const key = limitKey(scope, reading.label);
+        carried.add(key);
+        if (!applies(key))
+            continue;
+        entries.set(key, {
+            scope,
+            label: reading.label,
+            kind: 'reading',
+            checkedAt: at,
+            usedPercent: reading.usedPercent,
+            ...(reading.resetsAt === undefined ? {} : { resetsAt: reading.resetsAt }),
+            ...(reading.windowMinutes === undefined
+                ? {}
+                : { windowMinutes: reading.windowMinutes }),
+        });
+    }
+    for (const pair of observation.coverage ?? []) {
+        const scope = pair.scope ?? ALL_SCOPE;
+        const key = limitKey(scope, pair.label);
+        if (carried.has(key) || !applies(key))
+            continue;
+        const existing = entries.get(key);
+        entries.set(key, existing === undefined || existing.kind === 'absent'
+            ? { scope, label: pair.label, kind: 'absent', checkedAt: at }
+            : { scope, label: pair.label, kind: 'retired', retiredAt: at });
+    }
+    // Keys this module does not recognise are carried over untouched.
+    const { limits: _limits, budget: _budget, ...unknownKeys } = base;
+    const budget = mergeBudget(base.budget, observation.budget, at);
+    return {
+        ...unknownKeys,
+        limits: [...entries.values()].sort(compareEntries),
+        ...(budget === undefined ? {} : { budget }),
+    };
+}