@cortexkit/opencode-antigravity-auth 2.2.1 → 3.0.0

package/src/tui-ga-raw/shared/0e19a88ff3535906-command-dialogs.tsx

@@ -0,0 +1,468 @@
+/**
+ * The `/antigravity` drawer: one renderer for the server's command menu,
+ * shared by the OpenCode 1 and OpenCode GA TUIs.
+ *
+ * The server builds the whole menu with the shared command menu of
+ * `@cortexkit/common-auth/commands`: Accounts, Quota, Routing, Limits
+ * (killswitch), Cache, Diagnostics (logging and wire dump) and the plugin's
+ * extras (vault setup), each with its read-only lines, its items, and its
+ * actions with their typed inputs and confirmations. This file only walks
+ * that payload through the host's dialogs and sends back which action the
+ * user chose, by the opaque section, item and action ids the server gave.
+ * It never builds an account target of its own, never looks an account up
+ * by position, and never retries a choice against a different target: an id
+ * the server no longer knows comes back as a refused apply and the user sees
+ * the server's message.
+ *
+ * Every redraw after an apply uses the menu that apply returned, which the
+ * server built fresh for that answer; settings shown here are never a
+ * replay of an earlier answer.
+ *
+ * The drawer talks to the host only through `MenuUi` (dialog primitives as
+ * promises) and `MenuApply` (the transport), so the same code runs on both
+ * hosts. Nothing here writes to the terminal or picks colors.
+ */
+
+import {
+  type KnobValue,
+  MENU_REFUSED_TEXT,
+  type MenuAction,
+  type MenuApply,
+  type MenuApplyRequest,
+  type MenuApplyResult,
+  type MenuDialogPayload,
+  type MenuItem,
+  type MenuKnob,
+  type MenuModel,
+  type MenuSection,
+  type MenuSelectOption,
+  type MenuUi,
+} from "./07365a7d2ccade4c-host-api.js"
+
+const BACK = 'back'
+
+/** Text longer than this, or with a line break, is shown in full, not toasted. */
+const TOAST_MAX_LENGTH = 120
+
+/**
+ * Raised by a transport when an answer fails validation, so the drawer can
+ * tell a refused answer from an unreachable server.
+ */
+export class MenuRefusedError extends Error {
+  constructor(readonly issues: readonly string[]) {
+    super(MENU_REFUSED_TEXT)
+    this.name = 'MenuRefusedError'
+  }
+}
+
+function factLines(
+  facts: Readonly<Record<string, unknown>> | undefined,
+): string[] {
+  return Object.entries(facts ?? {}).map(
+    ([name, value]) =>
+      `${name}: ${typeof value === 'string' ? value : JSON.stringify(value)}`,
+  )
+}
+
+/** One option per section, in the order the menu gives them. */
+export function sectionListOptions(menu: MenuModel): MenuSelectOption[] {
+  return menu.sections.map((section) => ({
+    title: section.title,
+    value: `section:${section.id}`,
+    ...(section.lines[0] ? { description: section.lines[0] } : {}),
+  }))
+}
+
+/** Status text is a group header; every option navigates or runs an action. */
+export function sectionOptions(section: MenuSection): MenuSelectOption[] {
+  const header = [
+    ...section.lines,
+    ...factLines(section.facts),
+    ...section.items
+      .filter((item) => item.actions.length === 0)
+      .map((item) =>
+        [
+          item.group,
+          [item.label, item.status].filter(Boolean).join(' · '),
+          item.detail,
+          ...factLines(item.facts),
+        ]
+          .filter(Boolean)
+          .join('\n'),
+      ),
+  ]
+  const options: MenuSelectOption[] = [
+    ...section.items
+      .filter((item) => item.actions.length > 0)
+      .map((item) => ({
+        title: item.label,
+        value: `item:${item.id}`,
+        ...(item.detail ? { description: item.detail } : {}),
+        ...(item.group ? { category: item.group } : {}),
+        ...(item.status ? { footer: item.status } : {}),
+      })),
+    ...section.actions.map((action) => ({
+      title: action.label,
+      value: `action:${action.id}`,
+      ...(action.description ? { description: action.description } : {}),
+      ...(action.group ? { category: action.group } : {}),
+    })),
+    { title: 'Back', value: BACK },
+  ]
+  const first = options[0]
+  if (!first || header.length === 0) return options
+  const category = [...header, first.category].filter(Boolean).join('\n')
+  let firstGroup = true
+  return options.map((option) => {
+    if (option.category !== first.category) firstGroup = false
+    return firstGroup ? { ...option, category } : option
+  })
+}
+
+/** Item context stays in descriptions, never in rows that cannot be acted on. */
+export function itemOptions(item: MenuItem): MenuSelectOption[] {
+  const detail = [item.detail, ...factLines(item.facts)]
+    .filter(Boolean)
+    .join(' · ')
+  return [
+    ...item.actions.map((action) => ({
+      title: action.label,
+      value: `action:${action.id}`,
+      ...(detail || action.description
+        ? {
+            description: [detail, action.description]
+              .filter(Boolean)
+              .join(' · '),
+          }
+        : {}),
+      ...(action.group ? { category: action.group } : {}),
+    })),
+    { title: 'Back', value: BACK },
+  ]
+}
+
+/**
+ * The value a typed `number` or `text` input sends. Empty is `null` (the
+ * action reads that as "leave unset"); a number input sends a number when
+ * the text parses as one and the text otherwise, so the server can say what
+ * is wrong with it.
+ */
+export function promptValue(knob: MenuKnob, raw: string): KnobValue {
+  const text = raw.trim()
+  if (text === '') return null
+  if (knob.kind === 'number') {
+    const number = Number(text)
+    return Number.isFinite(number) ? number : text
+  }
+  return raw
+}
+
+function knobDefault(knob: MenuKnob): string {
+  if (knob.kind === 'toggle') return knob.value ? 'on' : 'off'
+  if (knob.kind === 'text' && knob.masked) return ''
+  return knob.value === undefined ? '' : String(knob.value)
+}
+
+/** The first web link in a message, such as a sign-in URL. */
+export function firstLink(text: string): string | undefined {
+  return /https?:\/\/\S+/.exec(text)?.[0]
+}
+
+export interface DrawerOptions {
+  readonly ui: MenuUi
+  readonly apply: MenuApply
+  /**
+   * Copies text to the clipboard; returns false when the terminal cannot.
+   * Absent when the host offers no clipboard.
+   */
+  readonly copy?: (text: string) => boolean
+  /** Receives drawer failures; must not write to the terminal. */
+  readonly onError?: (message: string, detail: Record<string, unknown>) => void
+  /** Opens on this section instead of the section list, when it exists. */
+  readonly startSection?: string
+}
+
+/**
+ * Opens the drawer on a payload the server pushed for `/antigravity`. The
+ * returned promise settles when the user closes the drawer.
+ */
+export function openAntigravityMenu(
+  options: DrawerOptions,
+  payload: MenuDialogPayload,
+): Promise<void> {
+  return new Drawer(options, payload.menu).start()
+}
+
+const CANCEL = '\u0000cancel'
+
+class Drawer {
+  private menu: MenuModel
+
+  constructor(
+    private readonly options: DrawerOptions,
+    menu: MenuModel,
+  ) {
+    this.menu = menu
+  }
+
+  async start(): Promise<void> {
+    const start = this.options.startSection
+    if (start && this.menu.sections.some((section) => section.id === start)) {
+      await this.section(start)
+      return
+    }
+    const only =
+      this.menu.sections.length === 1 ? this.menu.sections[0] : undefined
+    if (only) {
+      await this.section(only.id)
+      return
+    }
+    await this.list()
+  }
+
+  private async list(): Promise<void> {
+    const { ui } = this.options
+    const chosen = await ui.select({
+      title: this.menu.title,
+      options: sectionListOptions(this.menu),
+    })
+    if (chosen === undefined) return
+    await this.section(chosen.slice('section:'.length))
+  }
+
+  private async closeOrList(): Promise<void> {
+    if (this.menu.sections.length === 1) {
+      this.options.ui.clear()
+      return
+    }
+    await this.list()
+  }
+
+  private async section(sectionId: string): Promise<void> {
+    const { ui } = this.options
+    const section = this.menu.sections.find((entry) => entry.id === sectionId)
+    if (!section) {
+      ui.toast('That section is no longer offered.', 'warning')
+      await this.list()
+      return
+    }
+    const chosen = await ui.select({
+      title: section.title,
+      options: sectionOptions(section),
+    })
+    // Dismissing the dialog (Escape) closes the drawer; Back goes up a level.
+    if (chosen === undefined) return
+    if (chosen === BACK) {
+      await this.closeOrList()
+      return
+    }
+    if (chosen.startsWith('item:')) {
+      await this.item(section.id, chosen.slice('item:'.length))
+      return
+    }
+    if (chosen.startsWith('action:')) {
+      const action = section.actions.find(
+        (entry) => entry.id === chosen.slice('action:'.length),
+      )
+      if (action) {
+        await this.run(section, undefined, action)
+        return
+      }
+    }
+    // A read-only line: redraw the same section.
+    await this.section(section.id)
+  }
+
+  private async item(sectionId: string, itemId: string): Promise<void> {
+    const { ui } = this.options
+    const section = this.menu.sections.find((entry) => entry.id === sectionId)
+    const item = section?.items.find((entry) => entry.id === itemId)
+    if (!section || !item) {
+      ui.toast('That entry is no longer offered.', 'warning')
+      if (section) await this.section(section.id)
+      else await this.list()
+      return
+    }
+    const chosen = await ui.select({
+      title: `${section.title}: ${item.label}`,
+      options: itemOptions(item),
+    })
+    if (chosen === undefined) return
+    if (chosen === BACK) {
+      await this.section(section.id)
+      return
+    }
+    if (chosen.startsWith('action:')) {
+      const action = item.actions.find(
+        (entry) => entry.id === chosen.slice('action:'.length),
+      )
+      if (action) {
+        await this.run(section, item, action)
+        return
+      }
+    }
+    await this.item(section.id, item.id)
+  }
+
+  /** Asks for one input; resolves undefined when the user backs out. */
+  private async knob(
+    title: string,
+    knob: MenuKnob,
+  ): Promise<KnobValue | undefined> {
+    const { ui } = this.options
+    if (knob.kind === 'choice' || knob.kind === 'toggle') {
+      const choices: MenuSelectOption[] =
+        knob.kind === 'choice'
+          ? knob.choices.map((choice) => ({
+              title: choice.label,
+              value: choice.value,
+            }))
+          : [
+              { title: 'On', value: 'on' },
+              { title: 'Off', value: 'off' },
+            ]
+      const chosen = await ui.select({
+        title: `${title}: ${knob.label}`,
+        current: knobDefault(knob),
+        options: [...choices, { title: 'Cancel', value: CANCEL }],
+      })
+      if (chosen === undefined || chosen === CANCEL) return undefined
+      return knob.kind === 'toggle' ? chosen === 'on' : chosen
+    }
+    const placeholder = knob.kind === 'text' ? knob.placeholder : undefined
+    const raw = await ui.prompt({
+      title: `${title}: ${knob.label}`,
+      ...(placeholder ? { placeholder } : {}),
+      value: knobDefault(knob),
+    })
+    if (raw === undefined) return undefined
+    return promptValue(knob, raw)
+  }
+
+  private back(section: MenuSection, item: MenuItem | undefined) {
+    return item ? this.item(section.id, item.id) : this.section(section.id)
+  }
+
+  /**
+   * Collects an action's inputs, confirms it when it carries a confirmation,
+   * applies it and redraws from the refreshed menu.
+   */
+  private async run(
+    section: MenuSection,
+    item: MenuItem | undefined,
+    action: MenuAction,
+  ): Promise<void> {
+    const { ui } = this.options
+    const values: Record<string, KnobValue> = {}
+    for (const knob of action.knobs) {
+      const value = await this.knob(action.label, knob)
+      if (value === undefined) {
+        await this.back(section, item)
+        return
+      }
+      values[knob.id] = value
+    }
+    let confirmed = false
+    if (action.confirm) {
+      confirmed = await ui.confirm({
+        title: action.label,
+        message: action.confirm.message,
+      })
+      if (!confirmed) {
+        await this.back(section, item)
+        return
+      }
+    }
+    const request: MenuApplyRequest = {
+      command: this.menu.command,
+      sectionId: section.id,
+      ...(item ? { itemId: item.id } : {}),
+      actionId: action.id,
+      values,
+      ...(confirmed ? { confirmed: true as const } : {}),
+    }
+    let result = await this.send(request)
+    if (!result) {
+      await this.back(section, item)
+      return
+    }
+    if (result.needsConfirmation && !confirmed) {
+      const yes = await ui.confirm({
+        title: action.label,
+        message: result.text,
+      })
+      if (!yes) {
+        this.menu = result.menu
+        await this.section(section.id)
+        return
+      }
+      const again = await this.send({ ...request, confirmed: true })
+      if (!again) {
+        this.menu = result.menu
+        await this.back(section, item)
+        return
+      }
+      result = again
+    }
+    this.menu = result.menu
+    await this.finish(section.id, result)
+  }
+
+  private async send(
+    request: MenuApplyRequest,
+  ): Promise<MenuApplyResult | undefined> {
+    const { ui, apply, onError } = this.options
+    try {
+      return await apply(request)
+    } catch (error) {
+      if (error instanceof MenuRefusedError) {
+        onError?.('menu-apply-refused', { issues: error.issues })
+        ui.toast(MENU_REFUSED_TEXT, 'error')
+        return undefined
+      }
+      onError?.('menu-apply-failed', {
+        error: error instanceof Error ? error.name : typeof error,
+      })
+      ui.toast('The action could not reach Antigravity auth.', 'error')
+      return undefined
+    }
+  }
+
+  /**
+   * Shows the apply's message and returns to the section. A long message (a
+   * sign-in URL, a multi-line result) is shown in full; a link in it can be
+   * copied when the host has a clipboard. A short one is a toast.
+   */
+  private async finish(sectionId: string, result: MenuApplyResult) {
+    const { ui, copy } = this.options
+    const kind = result.ok ? 'info' : 'warning'
+    const long =
+      result.text.includes('\n') || result.text.length > TOAST_MAX_LENGTH
+    const link = firstLink(result.text)
+    if (link && copy) {
+      const chosen = await ui.select({
+        title: result.ok ? 'Done' : 'Not done',
+        options: [
+          { title: 'Copy link', value: 'copy', description: link },
+          { title: 'Continue', value: 'continue', description: result.text },
+        ],
+      })
+      if (chosen === 'copy') {
+        ui.toast(
+          copy(link)
+            ? 'Link copied to the clipboard.'
+            : 'Copy is unavailable here; select the link to copy it.',
+          'info',
+        )
+      }
+    } else if (long) {
+      await ui.alert({
+        title: result.ok ? 'Done' : 'Not done',
+        message: result.text,
+      })
+    } else {
+      ui.toast(result.text, kind)
+    }
+    await this.section(sectionId)
+  }
+}

package/src/tui-ga-raw/shared/1ff34afa7c42d196-projection.js

@@ -0,0 +1,134 @@
+// Projection of a keyed quota map onto one request scope.
+//
+// The selection primitives carried from openai-auth judge an account by a
+// short list of windows; the keyed map can hold many (scope, label) keys. The
+// projection resolves exactly one entry per window label for the request's
+// scope, orders the result the way the primitives expect, and carries each
+// entry's (scope, label) so a decision names the limit it judged rather than
+// the position it occupied.
+import { ALL_SCOPE, } from "./77138df80c7ae006-map.js";
+function project(entry) {
+    if (entry.kind === 'retired') {
+        return {
+            scope: entry.scope,
+            label: entry.label,
+            kind: 'retired',
+            checkedAt: entry.retiredAt,
+        };
+    }
+    if (entry.kind === 'absent') {
+        return {
+            scope: entry.scope,
+            label: entry.label,
+            kind: 'absent',
+            checkedAt: entry.checkedAt,
+        };
+    }
+    return {
+        scope: entry.scope,
+        label: entry.label,
+        kind: 'reading',
+        checkedAt: entry.checkedAt,
+        usedPercent: entry.usedPercent,
+        remainingPercent: 100 - entry.usedPercent,
+        ...(entry.windowMinutes === undefined
+            ? {}
+            : { windowMinutes: entry.windowMinutes }),
+        ...(entry.resetsAt === undefined ? {} : { resetsAt: entry.resetsAt }),
+    };
+}
+function compareLimits(left, right) {
+    const leftKnown = left.windowMinutes !== undefined;
+    const rightKnown = right.windowMinutes !== undefined;
+    if (leftKnown !== rightKnown)
+        return leftKnown ? -1 : 1;
+    if (leftKnown && rightKnown && left.windowMinutes !== right.windowMinutes) {
+        return (right.windowMinutes ?? 0) - (left.windowMinutes ?? 0);
+    }
+    if (left.label !== right.label)
+        return left.label < right.label ? -1 : 1;
+    return 0;
+}
+function projectBudget(budget) {
+    return {
+        checkedAt: budget.checkedAt,
+        reached: budget.reached,
+        ...(budget.remainingPercent === undefined
+            ? {}
+            : { remainingPercent: budget.remainingPercent }),
+        ...(budget.resetsAt === undefined ? {} : { resetsAt: budget.resetsAt }),
+    };
+}
+/**
+ * Resolves `map` for a request in `scope` (`all` or a model family). A family
+ * request sees only its own family's keys and the `all` keys.
+ *
+ * The label decides how a family limit relates to a general one. Under the
+ * same label, the family reading replaces the `all` reading: use this only
+ * when the provider's family figure is a more specific view of the same cap.
+ * Under different labels both limits are projected and every consumer judges
+ * both, so a family cap that applies on top of a general cap must be stored
+ * under its own label; otherwise the general cap is hidden from a family
+ * request. A family tombstone or absence record says only that no
+ * family-specific limit exists, so it does not hide an `all` entry for the
+ * same label and is used only when there is none.
+ */
+export function projectQuota(map, scope = ALL_SCOPE) {
+    const byLabel = new Map();
+    for (const entry of map?.limits ?? []) {
+        if (entry.scope !== scope && entry.scope !== ALL_SCOPE)
+            continue;
+        const current = byLabel.get(entry.label);
+        if (current === undefined) {
+            byLabel.set(entry.label, entry);
+            continue;
+        }
+        const family = entry.scope === ALL_SCOPE ? current : entry;
+        const general = entry.scope === ALL_SCOPE ? entry : current;
+        byLabel.set(entry.label, family.kind === 'reading' ? family : general);
+    }
+    const limits = [...byLabel.values()].map(project).sort(compareLimits);
+    const readings = limits.filter((limit) => limit.kind === 'reading');
+    const stamped = readings.length > 0 ? readings : limits;
+    const checkedAt = stamped.length > 0
+        ? Math.min(...stamped.map((limit) => limit.checkedAt))
+        : undefined;
+    const budget = map?.budget?.kind === 'reading' ? projectBudget(map.budget) : undefined;
+    return {
+        scope,
+        limits,
+        ...(checkedAt === undefined ? {} : { checkedAt }),
+        ...(budget === undefined ? {} : { budget }),
+    };
+}
+/**
+ * The credit budget's own exhaustion signal. Admission and the sticky
+ * routing decision to move a session off its pinned row both use it, so the
+ * two agree on what "spent" means. `reached` is the provider's
+ * verdict (the percentage is only a display value), and the check fails open
+ * on a missing, unparsable or already-passed reset.
+ */
+export function budgetExhaustedResetAt(quota, now) {
+    const budget = quota?.budget;
+    if (budget?.reached !== true || typeof budget.resetsAt !== 'string') {
+        return undefined;
+    }
+    const resetAtMs = Date.parse(budget.resetsAt);
+    if (!Number.isFinite(resetAtMs) || resetAtMs <= now)
+        return undefined;
+    return { resetsAt: budget.resetsAt, resetAtMs };
+}
+/** True for a reading at or beyond its whole window. */
+export function readsExhausted(limit) {
+    return (limit.kind === 'reading' &&
+        typeof limit.usedPercent === 'number' &&
+        Number.isFinite(limit.usedPercent) &&
+        limit.usedPercent >= 100);
+}
+/** The reset time of a limit when it parses and lies after `now`. */
+export function futureResetAt(limit, now) {
+    if (typeof limit.resetsAt !== 'string')
+        return undefined;
+    const resetAtMs = Date.parse(limit.resetsAt);
+    return Number.isFinite(resetAtMs) && resetAtMs > now ? resetAtMs : undefined;
+}

package/src/tui-ga-raw/shared/77138df80c7ae006-map.js

@@ -0,0 +1,105 @@
+// The per-row quota map: what the pool knows about one row's limits.
+//
+// A row's quota is a set of keyed limits. Each key is a (scope, window label)
+// pair: the scope is `all` for a limit that binds every request, or a model
+// family name for a limit that binds only that family; the label names the
+// window the provider reports (for example `primary` or `secondary`). Each key
+// holds one entry, which is either a reading, a retirement tombstone (the key
+// held a reading until an authoritative observation stopped reporting it), or
+// an absence record (an authoritative observation reported the key as having
+// no limit before any reading was seen). Tombstones and absence records are
+// evidence that the key is known to be unlimited; a missing key is unknown.
+//
+// Beside the limits sits the credit budget, a third pressure axis with its own
+// reset clock. It is a tri-state: absent (never reported), a reading, or
+// cleared (the provider reported that no budget exists).
+//
+// The map is plain JSON so the store can persist it without interpreting it.
+/** The scope of a limit that binds every request regardless of model. */
+export const ALL_SCOPE = 'all';
+/** The window label required when an admission call supplies none. */
+export const DEFAULT_REQUIRED_LABELS = Object.freeze([
+    'primary',
+]);
+export function emptyQuotaMap() {
+    return { limits: [] };
+}
+/** The time an entry speaks for: its reading, retirement or absence time. */
+export function entryTime(entry) {
+    return entry.kind === 'retired' ? entry.retiredAt : entry.checkedAt;
+}
+export function limitKey(scope, label) {
+    // JSON-encoding the pair keeps keys unambiguous for any scope or label text.
+    return JSON.stringify([scope, label]);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isName(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function optional(record, key, check) {
+    return record[key] === undefined || check(record[key]);
+}
+function isPositiveFinite(value) {
+    return isFiniteNumber(value) && value > 0;
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isQuotaEntry(value) {
+    if (!isRecord(value) || !isName(value.scope) || !isName(value.label)) {
+        return false;
+    }
+    switch (value.kind) {
+        case 'reading':
+            return (isFiniteNumber(value.checkedAt) &&
+                isFiniteNumber(value.usedPercent) &&
+                optional(value, 'resetsAt', isString) &&
+                optional(value, 'windowMinutes', isPositiveFinite));
+        case 'retired':
+            return isFiniteNumber(value.retiredAt);
+        case 'absent':
+            return isFiniteNumber(value.checkedAt);
+        default:
+            return false;
+    }
+}
+export function isCreditBudgetEntry(value) {
+    if (!isRecord(value) || !isFiniteNumber(value.checkedAt))
+        return false;
+    if (value.kind === 'cleared')
+        return true;
+    return (value.kind === 'reading' &&
+        typeof value.reached === 'boolean' &&
+        optional(value, 'remainingPercent', isFiniteNumber) &&
+        optional(value, 'usedPercent', isFiniteNumber) &&
+        optional(value, 'resetsAt', isString) &&
+        optional(value, 'limit', isFiniteNumber) &&
+        optional(value, 'used', isFiniteNumber) &&
+        optional(value, 'remaining', isFiniteNumber) &&
+        optional(value, 'unit', isString));
+}
+/**
+ * True when `value` is a well-formed quota map. Unrecognised top-level keys
+ * are tolerated (and preserved by merge) so a newer writer's additions
+ * survive; a malformed entry, a duplicated (scope, label) key or a malformed
+ * budget makes the whole map invalid.
+ */
+export function isQuotaMap(value) {
+    if (!isRecord(value) || !Array.isArray(value.limits))
+        return false;
+    const seen = new Set();
+    for (const entry of value.limits) {
+        if (!isQuotaEntry(entry))
+            return false;
+        const key = limitKey(entry.scope, entry.label);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+    }
+    return optional(value, 'budget', isCreditBudgetEntry);
+}