@cortexkit/opencode-antigravity-auth 2.2.1 → 3.0.0

package/src/tui-ga-compiled/shared/0e19a88ff3535906-command-dialogs.js

@@ -0,0 +1,424 @@
+/**
+ * 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 { MENU_REFUSED_TEXT } 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(issues) {
+    super(MENU_REFUSED_TEXT);
+    this.issues = issues;
+    this.name = 'MenuRefusedError';
+  }
+}
+function factLines(facts) {
+  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) {
+  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) {
+  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 = [...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) {
+  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, raw) {
+  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) {
+  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) {
+  return /https?:\/\/\S+/.exec(text)?.[0];
+}
+/**
+ * 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, payload) {
+  return new Drawer(options, payload.menu).start();
+}
+const CANCEL = '\u0000cancel';
+class Drawer {
+  constructor(options, menu) {
+    this.options = options;
+    this.menu = menu;
+  }
+  async start() {
+    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();
+  }
+  async list() {
+    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));
+  }
+  async closeOrList() {
+    if (this.menu.sections.length === 1) {
+      this.options.ui.clear();
+      return;
+    }
+    await this.list();
+  }
+  async section(sectionId) {
+    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);
+  }
+  async item(sectionId, itemId) {
+    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. */
+  async knob(title, knob) {
+    const {
+      ui
+    } = this.options;
+    if (knob.kind === 'choice' || knob.kind === 'toggle') {
+      const choices = 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);
+  }
+  back(section, item) {
+    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.
+   */
+  async run(section, item, action) {
+    const {
+      ui
+    } = this.options;
+    const values = {};
+    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 = {
+      command: this.menu.command,
+      sectionId: section.id,
+      ...(item ? {
+        itemId: item.id
+      } : {}),
+      actionId: action.id,
+      values,
+      ...(confirmed ? {
+        confirmed: true
+      } : {})
+    };
+    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);
+  }
+  async send(request) {
+    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.
+   */
+  async finish(sectionId, result) {
+    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-compiled/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-compiled/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);
+}