@cortexkit/opencode-antigravity-auth 1.1.0 → 2.0.0

package/src/tui/command-dialogs.tsx

@@ -0,0 +1,699 @@
+/** @jsxImportSource @opentui/solid */
+
+/**
+ * Imperative command-dialog dispatcher for the /antigravity-* slash commands.
+ *
+ * Mirrors the fleet sibling layout (see `anthropic-auth-live` /
+ * `openai-auth-live` `packages/opencode/src/tui/command-dialogs.tsx`):
+ * each command's dialog opens with its data/status content rendered into the
+ * dialog BODY as a column of plain `<text>` nodes — non-selectable,
+ * non-searchable — and a separate `<DialogSelect>` below carries ONLY the
+ * real actions with proper `{title, description}` shapes the host renders
+ * on separate lines. The earlier implementation crammed the data rows into
+ * `DialogSelect`'s `placeholder` (which participates in type-ahead search)
+ * and concatenated label+description into a single highlighted option line;
+ * this rewrite separates data from actions the way the host expects.
+ *
+ * Contract:
+ * - Every main/subdialog calls `api.ui.dialog.setSize('xlarge')` before
+ *   `api.ui.dialog.replace()` so the host reserves enough width for the
+ *   longest line in any branch.
+ * - `apply(command, args, options?)` is the RPC apply path the dispatch
+ *   site (the module-scoped poll in `tui.tsx`) supplies. The dispatcher
+ *   forwards `options.timeoutMs` so a long-running apply (account add /
+ *   refresh, future quota refresh) gets the right RPC timeout.
+ * - All `DialogSelect` options must remain VISIBLE — the host's
+ *   `disabled: true` is a hard hide, so this file must never set it.
+ *   Invalid actions stay visible with an explanatory description and are
+ *   rejected in `onSelect`. The `no hide-property option scan` test in
+ *   the verification gates pins this contract.
+ * - `onSelect` awaits the apply, toasts the result, then either clears
+ *   the dialog or replaces it for multi-step flows. The dialog stack
+ *   never sees a `clear()` between apply and re-render so the user
+ *   always sees feedback (per the dispatcher contract).
+ */
+
+import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
+import type { CommandAccountRow } from '../plugin/command-data'
+import type { CommandModalName, OpenDialogPayload } from '../rpc/protocol'
+
+/**
+ * Apply handler the dispatcher calls when the user selects a dialog
+ * option. Mirrors `ApplyRequest` from `rpc/protocol` plus the
+ * `RpcRequestOptions.timeoutMs` knob the RPC client already accepts —
+ * the call site in `tui.tsx` forwards these directly into
+ * `rpcClient.apply(request, options)`.
+ */
+export type ApplyFn = (
+  command: CommandModalName,
+  args: string,
+  options?: { timeoutMs?: number },
+) => Promise<{ text: string; knobs: Record<string, unknown> }>
+
+/**
+ * Mount the dialog for `payload.command` on the live TUI.
+ *
+ * The dispatcher branches on `payload.command` — each branch is
+ * self-contained: render the data body, render the host DialogSelect
+ * below it with the real actions, wire `onSelect` to await `apply(...)`,
+ * then toast the result and clear (or replace for multi-step flows).
+ * Unknown commands throw so a future command registered in
+ * `MODAL_COMMANDS` without a dispatcher branch fails loudly at the first
+ * dialog open.
+ */
+export function openCommandDialog(
+  api: TuiPluginApi,
+  payload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  if (payload.command === 'antigravity-dump') {
+    renderDumpDialog(api, payload, apply)
+    return
+  }
+  if (payload.command === 'antigravity-logging') {
+    renderLoggingDialog(api, payload, apply)
+    return
+  }
+  if (payload.command === 'antigravity-quota') {
+    throw new Error('antigravity-quota is rendered by the TUI quota panel')
+  }
+  if (payload.command === 'antigravity-account') {
+    renderAccountDialog(api, payload, apply)
+    return
+  }
+  if (payload.command === 'antigravity-routing') {
+    renderRoutingDialog(api, payload, apply)
+    return
+  }
+  if (payload.command === 'antigravity-killswitch') {
+    renderKillswitchDialog(api, payload, apply)
+    return
+  }
+  const exhaustiveCheck: never = payload.command
+  throw new Error(`Unknown command ${exhaustiveCheck as string}`)
+}
+
+// ---------------------------------------------------------------------------
+// Fully wired branches — non-data-first dialogs.
+// ---------------------------------------------------------------------------
+
+/**
+ * /antigravity-dump: three actions (on / off / status). Each selection
+ * applies through the RPC, toasts the result text, and clears the
+ * dialog. Status is a read-only check that still goes through apply so
+ * the dump helper runs once and reports the current state.
+ */
+function renderDumpDialog(
+  api: TuiPluginApi,
+  _payload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  const DialogSelect = api.ui.DialogSelect<string>
+  api.ui.dialog.setSize('xlarge')
+  api.ui.dialog.replace(() => (
+    <DialogSelect
+      title='Antigravity wire dump'
+      options={[
+        {
+          title: 'Turn dump on',
+          value: 'on',
+          description: 'Write request and response bodies to the dump dir.',
+        },
+        {
+          title: 'Turn dump off',
+          value: 'off',
+          description: 'Stop writing new dump files.',
+        },
+        {
+          title: 'Show dump status',
+          value: 'status',
+          description: 'Display whether dumps are enabled and where they go.',
+        },
+      ]}
+      onSelect={(option) => {
+        void apply('antigravity-dump', String(option.value)).then((result) => {
+          api.ui.toast({ message: result.text })
+          api.ui.dialog.clear()
+        })
+      }}
+    />
+  ))
+}
+
+/**
+ * /antigravity-logging: every log level as an option. The dispatcher
+ * forwards the level as the apply arg; the apply path persists it
+ * through `OperatorSettingsController` and toasts the resolution text.
+ */
+function renderLoggingDialog(
+  api: TuiPluginApi,
+  payload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  const DialogSelect = api.ui.DialogSelect<string>
+  const current = (payload.knobs.log_level as string) ?? 'info'
+  api.ui.dialog.setSize('xlarge')
+  api.ui.dialog.replace(() => (
+    <DialogSelect
+      title='Antigravity logging'
+      current={current}
+      options={[
+        { title: 'Error', value: 'error', description: 'Errors only.' },
+        { title: 'Warn', value: 'warn', description: 'Warnings and errors.' },
+        {
+          title: 'Info',
+          value: 'info',
+          description: 'Default. Includes informational events.',
+        },
+        {
+          title: 'Debug',
+          value: 'debug',
+          description: 'Includes debug-level events.',
+        },
+        {
+          title: 'Trace',
+          value: 'trace',
+          description: 'Most verbose — every diagnostic event.',
+        },
+      ]}
+      onSelect={(option) => {
+        void apply('antigravity-logging', String(option.value)).then(
+          (result) => {
+            api.ui.toast({ message: result.text })
+            api.ui.dialog.clear()
+          },
+        )
+      }}
+    />
+  ))
+}
+
+// ---------------------------------------------------------------------------
+// Shared helpers — render data rows as plain text in the dialog body.
+// ---------------------------------------------------------------------------
+
+function formatQuotaRowLine(row: CommandAccountRow): string {
+  const status = row.enabled ? '' : ' (disabled)'
+  const current = row.current ? ' *' : ''
+  if (row.quota.length === 0) {
+    return `${row.label}${status}${current}: no cached quota`
+  }
+  const parts = row.quota.map((q) => {
+    const pct = q.remainingPercent == null ? '–%' : `${q.remainingPercent}%`
+    return `${q.label} ${pct}`
+  })
+  return `${row.label}${status}${current}: ${parts.join(', ')}`
+}
+
+/**
+ * /antigravity-account data-first dialog.
+ *
+ * The body lists each account row as a plain `<text>` node (cache-only
+ * — no network I/O on open). The DialogSelect carries ONLY real
+ * actions: Add account… and one drill-in entry per row. Drill-in
+ * navigates to a row-level subdialog that exposes toggle / set-current
+ * / remove with a DialogConfirm gate for the destructive path.
+ *
+ * Each action calls `apply('antigravity-account', '<verb> <index>')`,
+ * which the apply path translates into a locked-storage mutation.
+ * The service returns fresh `CommandAccountRow[]`; the dialog mutates
+ * its closed-over payload and re-renders via `renderMain()` so the
+ * user never sees a clear-then-redraw gap.
+ */
+function renderAccountDialog(
+  api: TuiPluginApi,
+  initialPayload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  // Closed-over payload: every render reads from the latest snapshot.
+  const payload: OpenDialogPayload = { ...initialPayload }
+
+  const rowsFromKnobs = (): CommandAccountRow[] => {
+    const raw = payload.knobs.accounts
+    return Array.isArray(raw) ? (raw as CommandAccountRow[]) : []
+  }
+
+  const runApply = async (
+    args: string,
+    options?: { timeoutMs?: number },
+  ): Promise<CommandAccountRow[] | null> => {
+    const result = await apply('antigravity-account', args, options)
+    api.ui.toast({ message: result.text })
+    const next = result.knobs.accounts
+    if (Array.isArray(next)) {
+      payload.knobs = {
+        ...payload.knobs,
+        accounts: next as CommandAccountRow[],
+      }
+      renderMain()
+      return next as CommandAccountRow[]
+    }
+    renderMain()
+    return null
+  }
+
+  const renderManageRow = (row: CommandAccountRow): void => {
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <box flexDirection='column' padding={1} width='100%'>
+        <text>{row.label}</text>
+        <text>
+          {row.quota.length === 0
+            ? 'no cached quota'
+            : row.quota
+                .map((q) =>
+                  q.remainingPercent == null
+                    ? `${q.label} –%`
+                    : `${q.label} ${q.remainingPercent}%`,
+                )
+                .join(', ')}
+        </text>
+        <box marginTop={1}>
+          <DialogSelect
+            title={`Manage ${row.label}`}
+            options={[
+              {
+                title: row.enabled ? 'Disable account' : 'Enable account',
+                value: `toggle ${row.index}`,
+                description: row.enabled
+                  ? 'Skip this account in rotation when its quota is low.'
+                  : 'Include this account in rotation again.',
+              },
+              {
+                title: 'Set as current',
+                value: `current ${row.index}`,
+                description:
+                  'Pin this account as the active Claude + Gemini choice.',
+              },
+              {
+                title: 'Remove account…',
+                value: `__remove_prompt__ ${row.index}`,
+                description:
+                  'Permanently delete this account from the local pool.',
+              },
+              {
+                title: 'Back',
+                value: '__back__',
+                description: 'Return to the account list.',
+              },
+            ]}
+            onSelect={(option) => {
+              const raw = String(option.value)
+              if (raw === '__back__') {
+                renderMain()
+                return
+              }
+              if (raw.startsWith('__remove_prompt__ ')) {
+                const targetIndex = Number.parseInt(raw.split(' ')[1] ?? '', 10)
+                promptRemove(targetIndex)
+                return
+              }
+              if (raw.startsWith('toggle ') || raw.startsWith('current ')) {
+                void runApply(raw, { timeoutMs: 2_000 }).catch(() => {
+                  api.ui.toast({
+                    message: `${row.label}: action failed`,
+                  })
+                })
+                return
+              }
+              api.ui.toast({
+                message: `${row.label}: unknown action`,
+              })
+            }}
+          />
+        </box>
+      </box>
+    ))
+  }
+
+  const promptRemove = (index: number): void => {
+    const DialogConfirm = api.ui.DialogConfirm
+    const row = rowsFromKnobs()[index]
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogConfirm
+        title='Remove account'
+        message={`Permanently remove ${row?.label ?? `account ${index + 1}`} from the local pool? This cannot be undone.`}
+        onConfirm={async () => {
+          try {
+            const next = await runApply(`remove ${index}`, {
+              timeoutMs: 2_000,
+            })
+            if (next === null) {
+              renderMain()
+            }
+          } catch {
+            api.ui.toast({ message: 'Account remove failed' })
+            renderMain()
+          }
+        }}
+        onCancel={() => {
+          renderMain()
+        }}
+      />
+    ))
+  }
+
+  const renderMain = (): void => {
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    const rows = rowsFromKnobs()
+    const bodyLines = rows.length
+      ? rows.map(formatQuotaRowLine)
+      : ['No accounts configured. Add one via the menu below.']
+    api.ui.dialog.replace(() => (
+      <box flexDirection='column' padding={1} width='100%'>
+        {bodyLines.map((line) => (
+          <text>{line}</text>
+        ))}
+        <box marginTop={1}>
+          <DialogSelect
+            title='Antigravity accounts'
+            options={[
+              {
+                title: 'Add account…',
+                value: 'add',
+                description:
+                  'Open the OAuth flow to add a new account (120s timeout).',
+              },
+              ...rows.map((row) => ({
+                title: row.label,
+                value: `__manage__ ${row.index}`,
+                description: row.enabled
+                  ? row.current
+                    ? 'Current account — toggle, remove, or back.'
+                    : 'Enabled — toggle, set as current, or remove.'
+                  : 'Disabled — toggle to re-enable, or remove.',
+              })),
+              { title: 'Back', value: 'back' },
+            ]}
+            onSelect={(option) => {
+              const raw = String(option.value)
+              if (raw === 'back') {
+                api.ui.dialog.clear()
+                return
+              }
+              if (raw === 'add') {
+                void runApply('add', { timeoutMs: 120_000 }).catch(() => {
+                  api.ui.toast({ message: 'Account add failed' })
+                })
+                return
+              }
+              if (raw.startsWith('__manage__ ')) {
+                const targetIndex = Number.parseInt(raw.split(' ')[1] ?? '', 10)
+                const target = rows[targetIndex]
+                if (target) renderManageRow(target)
+                return
+              }
+              api.ui.toast({ message: 'Unknown action' })
+            }}
+          />
+        </box>
+      </box>
+    ))
+  }
+
+  renderMain()
+}
+
+/**
+ * /antigravity-routing data-first dialog.
+ *
+ * The body lists the current persisted values (`cli_first`,
+ * `quota_style_fallback`) as plain `<text>` nodes so the data is
+ * visible without filtering the action list. The DialogSelect carries
+ * ONLY real toggle actions — each row flips exactly one flag, awaits
+ * apply, toasts the result, and re-renders in place from the
+ * freshly-returned state.
+ *
+ * Re-render contract mirrors the quota/account dialogs: the
+ * closed-over `payload.knobs` is mutated with the apply response and
+ * `renderMain()` is re-invoked. The dialog stack never sees a
+ * `clear()` between apply and re-render.
+ *
+ * Error path: when apply returns a `knobs.error === true` payload
+ * (lock contention, unreadable config), the dispatcher does NOT swap
+ * the closed-over payload — the dialog stays mounted on the previous
+ * state so the user can retry or back out. The error message was
+ * already toasted by `runApply`.
+ */
+function renderRoutingDialog(
+  api: TuiPluginApi,
+  initialPayload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  // Closed-over payload: every render reads from the latest snapshot.
+  const payload: OpenDialogPayload = { ...initialPayload }
+
+  const readRouting = (): { cliFirst: boolean; quotaFallback: boolean } => ({
+    cliFirst: payload.knobs.cli_first === true,
+    quotaFallback: payload.knobs.quota_style_fallback === true,
+  })
+
+  const runApply = async (args: string): Promise<void> => {
+    const result = await apply('antigravity-routing', args, {
+      timeoutMs: 2_000,
+    })
+    api.ui.toast({ message: result.text })
+    if (result.knobs.error === true) {
+      return
+    }
+    payload.knobs = {
+      ...payload.knobs,
+      cli_first: result.knobs.cli_first,
+      quota_style_fallback: result.knobs.quota_style_fallback,
+    }
+    renderMain()
+  }
+
+  const renderMain = (): void => {
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    const { cliFirst, quotaFallback } = readRouting()
+    const bodyLines = [
+      `cli_first: ${cliFirst ? 'on' : 'off'}`,
+      `quota_style_fallback: ${quotaFallback ? 'on' : 'off'}`,
+    ]
+    api.ui.dialog.replace(() => (
+      <box flexDirection='column' padding={1} width='100%'>
+        {bodyLines.map((line) => (
+          <text>{line}</text>
+        ))}
+        <box marginTop={1}>
+          <DialogSelect
+            title='Antigravity routing'
+            options={[
+              {
+                title: `${cliFirst ? '●' : '○'} cli_first: ${cliFirst}`,
+                value: `cli_first=${!cliFirst}`,
+                description: cliFirst
+                  ? 'CLI is preferred before Antigravity. Click to turn off.'
+                  : 'Antigravity runs before CLI. Click to turn on.',
+              },
+              {
+                title: `${quotaFallback ? '●' : '○'} quota_style_fallback: ${quotaFallback}`,
+                value: `quota_style_fallback=${!quotaFallback}`,
+                description: quotaFallback
+                  ? 'Falls back to the alternate quota style on exhaustion. Click to turn off.'
+                  : 'No quota-style fallback today. Click to turn on.',
+              },
+              { title: 'Back', value: 'back' },
+            ]}
+            onSelect={(option) => {
+              const raw = String(option.value)
+              if (raw === 'back') {
+                api.ui.dialog.clear()
+                return
+              }
+              if (
+                !raw.startsWith('cli_first=') &&
+                !raw.startsWith('quota_style_fallback=')
+              ) {
+                api.ui.toast({ message: 'Unknown routing action' })
+                return
+              }
+              void runApply(raw).catch(() => {
+                api.ui.toast({ message: 'Routing update failed' })
+                renderMain()
+              })
+            }}
+          />
+        </box>
+      </box>
+    ))
+  }
+
+  renderMain()
+}
+
+/**
+ * /antigravity-killswitch data-first dialog.
+ *
+ * The body lists the current persisted killswitch state (`enabled`,
+ * `minimum_remaining_percent`, and the per-account override map) as
+ * plain `<text>` nodes. The DialogSelect carries ONLY real actions:
+ * the global enabled toggle, the threshold-edit prompt, and a Back
+ * affordance. The threshold edit opens a DialogPrompt for a fresh
+ * integer in `0..100`; out-of-range input stays at the prompt without
+ * applying.
+ *
+ * Re-render contract matches the routing dialog: the closed-over
+ * `payload.knobs` is swapped to the apply response on success and
+ * `renderMain()` re-runs. Errors leave the payload untouched.
+ */
+function renderKillswitchDialog(
+  api: TuiPluginApi,
+  initialPayload: OpenDialogPayload,
+  apply: ApplyFn,
+): void {
+  const payload: OpenDialogPayload = { ...initialPayload }
+
+  const readKillswitch = (): {
+    enabled: boolean
+    minimum: number
+    accounts: Record<string, number>
+  } => {
+    const enabled = payload.knobs.enabled === true
+    const rawMin = payload.knobs.minimum_remaining_percent
+    const minimum =
+      typeof rawMin === 'number' && Number.isFinite(rawMin)
+        ? Math.max(0, Math.min(100, Math.round(rawMin)))
+        : 0
+    const rawAccounts = payload.knobs.accounts
+    const accounts =
+      rawAccounts &&
+      typeof rawAccounts === 'object' &&
+      !Array.isArray(rawAccounts)
+        ? (rawAccounts as Record<string, number>)
+        : {}
+    return { enabled, minimum, accounts }
+  }
+
+  const runApply = async (args: string): Promise<void> => {
+    const result = await apply('antigravity-killswitch', args, {
+      timeoutMs: 2_000,
+    })
+    api.ui.toast({ message: result.text })
+    if (result.knobs.error === true) {
+      return
+    }
+    payload.knobs = {
+      ...payload.knobs,
+      enabled: result.knobs.enabled,
+      minimum_remaining_percent: result.knobs.minimum_remaining_percent,
+      accounts: result.knobs.accounts ?? {},
+    }
+    renderMain()
+  }
+
+  const openThresholdPrompt = (currentMinimum: number): void => {
+    const DialogPrompt = api.ui.DialogPrompt
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogPrompt
+        title='Antigravity killswitch — set threshold'
+        description={() => (
+          <text>
+            Enter a new minimum_remaining_percent (0-100). Empty input cancels.
+          </text>
+        )}
+        placeholder={`${currentMinimum}`}
+        value={`${currentMinimum}`}
+        onConfirm={(value: string) => {
+          const trimmed = value.trim()
+          if (!trimmed) {
+            renderMain()
+            return
+          }
+          const parsed = Number.parseInt(trimmed, 10)
+          if (
+            !Number.isInteger(parsed) ||
+            parsed < 0 ||
+            parsed > 100 ||
+            String(parsed) !== trimmed
+          ) {
+            api.ui.toast({
+              message: 'Threshold must be an integer between 0 and 100',
+            })
+            openThresholdPrompt(currentMinimum)
+            return
+          }
+          void runApply(`minimum_remaining_percent=${parsed}`).catch(() => {
+            api.ui.toast({ message: 'Killswitch update failed' })
+            renderMain()
+          })
+        }}
+        onCancel={() => {
+          renderMain()
+        }}
+      />
+    ))
+  }
+
+  const renderMain = (): void => {
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    const { enabled, minimum, accounts } = readKillswitch()
+    const accountKeys = Object.keys(accounts)
+    const bodyLines = [
+      `Killswitch: ${enabled ? 'enabled' : 'disabled'}`,
+      `Minimum remaining percent: ${minimum}%`,
+      ...(accountKeys.length > 0
+        ? [
+            'Per-account overrides:',
+            ...accountKeys.map((key) => `  ${key}: ${accounts[key] ?? 0}%`),
+          ]
+        : []),
+    ]
+    api.ui.dialog.replace(() => (
+      <box flexDirection='column' padding={1} width='100%'>
+        {bodyLines.map((line) => (
+          <text>{line}</text>
+        ))}
+        <box marginTop={1}>
+          <DialogSelect
+            title='Antigravity killswitch'
+            options={[
+              {
+                title: `${enabled ? '●' : '○'} Killswitch: ${enabled ? 'enabled' : 'disabled'}`,
+                value: `enabled=${!enabled}`,
+                description: enabled
+                  ? 'Drop candidates below the floor before dispatch. Click to turn off.'
+                  : 'Resume candidate selection regardless of quota. Click to turn on.',
+              },
+              {
+                title: `Set minimum remaining percent (${minimum}%)`,
+                value: '__edit_threshold__',
+                description:
+                  'Prompt for a new global floor (0-100). Per-account overrides are listed above.',
+              },
+              { title: 'Back', value: 'back' },
+            ]}
+            onSelect={(option) => {
+              const raw = String(option.value)
+              if (raw === 'back') {
+                api.ui.dialog.clear()
+                return
+              }
+              if (raw === '__edit_threshold__') {
+                openThresholdPrompt(minimum)
+                return
+              }
+              if (raw === 'enabled=true' || raw === 'enabled=false') {
+                void runApply(raw).catch(() => {
+                  api.ui.toast({ message: 'Killswitch update failed' })
+                  renderMain()
+                })
+                return
+              }
+              api.ui.toast({ message: 'Unknown killswitch action' })
+            }}
+          />
+        </box>
+      </box>
+    ))
+  }
+
+  renderMain()
+}