@cortexkit/opencode-openai-auth 1.0.5 → 1.1.0

package/src/tui-compiled/raw/shared/e8cd4929507508d8-refresh-file-lock.js

@@ -1,8 +1,25 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, open, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createPrivateBytes, createPrivateDirectoryExclusive, ensurePrivateDirectory, PrivateFileError, privateOperation, readPrivateText, verifyPrivate, windowsPrivateFiles, writePrivateAtomic, } from "./375d9cca2def037d-private-files.js";
 import { LockOwnershipError, lockPathFor } from "./4825e03209d6ae3e-with-lock.js";
+/**
+ * Create a new owner-only file and write `text` into it, failing with EEXIST if
+ * the file already exists. Writing through the handle rather than path-based
+ * `writeFile(path, …, { flag: 'wx' })` matters: Bun's path form also truncates
+ * the file it has just created, and on some Linux filesystems (XFS under load)
+ * that redundant ftruncate stalls for hundreds of milliseconds, inside every
+ * lock acquisition.
+ */
+async function createExclusiveText(path, text) {
+    const handle = await open(path, 'wx', 0o600);
+    try {
+        await handle.writeFile(text, 'utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
 const setRefreshLockRenewalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearRefreshLockRenewalTimeout = globalThis.clearTimeout.bind(globalThis);
 // A concurrent contender renaming the freshly-created eviction-marker directory
@@ -14,7 +31,12 @@ export function isLostMarkerRaceError(error) {
     return (code === 'ENOENT' ||
         (!windowsPrivateFiles && (code === 'EINVAL' || code === 'ENOTDIR')));
 }
-export async function acquireRefreshFileLock(options) {
+/** Filesystem leases share wall time across all callers and processes. */
+export function acquireRefreshFileLock(options) {
+    return acquireRefreshFileLockWithClock({ ...options, now: Date.now });
+}
+/** @internal Clock seam for lease tests; not exported by the package's fs entry point. */
+export async function acquireRefreshFileLockWithClock(options) {
     const lockPath = lockPathFor(options.path, options.name);
     const legacyOwnerPath = join(lockPath, 'owner.json');
     const ownerId = randomUUID();
@@ -152,11 +174,7 @@ export async function acquireRefreshFileLock(options) {
         if (windowsPrivateFiles)
             await createPrivateBytes(lockPath, bytes);
         else
-            await writeFile(lockPath, bytes, {
-                encoding: 'utf8',
-                mode: 0o600,
-                flag: 'wx',
-            });
+            await createExclusiveText(lockPath, bytes);
     }
     async function leaseContention(error) {
         const code = error.code;
@@ -304,11 +322,7 @@ export async function acquireRefreshFileLock(options) {
             if (windowsPrivateFiles)
                 await createPrivateBytes(evictOwnerPath, bytes);
             else
-                await writeFile(evictOwnerPath, bytes, {
-                    encoding: 'utf8',
-                    mode: 0o600,
-                    flag: 'wx',
-                });
+                await createExclusiveText(evictOwnerPath, bytes);
         }
         catch (error) {
             // A competing contender can rename our just-created marker directory

package/src/tui-compiled/raw/shared/e8d3c8da776ef9cd-index.js

@@ -0,0 +1,24 @@
+// Claustrum vault custody shared by the auth plugins: scoped enrollment (run
+// from setup), discovery of this consumer's vault accounts as rows for this
+// package's `/routing` subpath, per-send authorization, 401 reporting, the
+// declined-account interlock and the host-slot guard. Needs the optional
+// peer `@cortexkit/claustrum-client`.
+import { ClaustrumClient, } from "@cortexkit/claustrum-client";
+import { insulaUsageTransport } from "./d0f0b6be200311af-insula.js";
+export { ClaustrumCredentialError, } from "@cortexkit/claustrum-client";
+export { ClaustrumConsumer, } from "./169b2b4bf30909bc-consumer.js";
+export { ClaustrumScopedCustody, decideScopedRetryAfter401, isScopedCredentialRotation, SERVING_MARGIN_MS, } from "./0f77ebc3c914c9c6-custody.js";
+export { ClaustrumEnrollmentManager, classifyEnrollmentError, connectClaustrumEnrollmentClient, disconnectClaustrumEnrollment, enrollmentAuthority, enrollmentName, getClaustrumEnrollmentPaths, hostEnrollmentPaths, RETRYABLE_ENROLLMENT_CODES, readClaustrumEnrollmentStatus, readClaustrumEnrollmentToken, resetClaustrumEnrollmentState, TERMINAL_ENROLLMENT_CODES, } from "./b9588ad4725c1d10-enrollment.js";
+export { ClaustrumConsumerError, } from "./ca0fccaba1d87af4-errors.js";
+export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, isCustodyPlaceholder, isCustodyPlaceholderValue, } from "./d9d2892a4c371301-host-slot.js";
+export { acceptAccount, declineAccount, isDeclined, } from "./7c140680fc81be92-interlock.js";
+export { acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, mutateVaultRoster, projectVaultRoster, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
+/**
+ * Connect the client that lists and fetches this consumer's vault credentials
+ * on the request path. `connectionFile` is required: this library
+ * reads no environment, so the plugin resolves the vault's connection file.
+ */
+export async function connectClaustrumScopedClient(options) {
+    const client = await ClaustrumClient.connect(options);
+    return Object.assign(client, { insula: insulaUsageTransport(options) });
+}

package/src/tui-compiled/raw/sidebar-state.js

@@ -3,6 +3,11 @@ import {
   projectQuota,
   quotaWindowName
 } from "./shared/d5a8f1061ee2f114-index.js";
+import { orderForPlacement } from "./shared/3e7d45a77c6ad4d5-index.js";
+import {
+  orderedPlacement,
+  vaultMainRouteId
+} from "./shared/abd062d633e29fd2-pool-routing.js";
 const QUOTA_WINDOW_KEYS = ["primary", "secondary"], LEGACY_WINDOW_MINUTES = {
   primary: 300,
   secondary: 10080
@@ -167,11 +172,14 @@ function normalizeAccountList(raw) {
     return [];
   return raw.filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && typeof entry.id === "string").map((e) => ({
     id: e.id,
+    ...typeof e.credentialId === "string" ? { credentialId: e.credentialId } : {},
     label: typeof e.label === "string" ? e.label : void 0,
     ...typeof e.accountId === "string" ? { accountId: e.accountId } : {},
     quota: "quota" in e ? e.quota : null,
     killed: typeof e.killed === "boolean" ? e.killed : !1,
     enabled: typeof e.enabled === "boolean" ? e.enabled : !0,
+    ...typeof e.routable === "boolean" ? { routable: e.routable } : {},
+    ...["needs sign-in", "turned off in vault", "unavailable"].includes(e.vaultState) ? { vaultState: e.vaultState } : {},
     ...resetCreditsField(e.resetCredits)
   }));
 }
@@ -192,7 +200,7 @@ export function isUsableRoutingEntry(entry, accounts, now = Date.now()) {
     return !1;
   if (accounts === void 0)
     return !0;
-  return entry.activeId === "main" || accounts.some((account) => account.enabled !== !1 && account.killed !== !0 && account.id === entry.activeId);
+  return entry.activeId === "main" || accounts.some((account) => account.enabled !== !1 && account.routable !== !1 && account.killed !== !0 && account.id === entry.activeId);
 }
 export function spendControlExhaustedResetAt(quota, now = Date.now()) {
   const spendControl = quota?.spendControl;
@@ -229,28 +237,40 @@ export function resolveSessionStickyAccount(state, sessionId, now = Date.now())
   const assignment = state.stickyAssignments?.[hashSidebarSessionId(sessionId)];
   if (!assignment || assignment.lastSeenAt < now - STICKY_ASSIGNMENT_MAX_AGE_MS)
     return;
-  if (assignment.accountId === "main")
+  if (assignment.accountId === "main" && state.vaultAccounts === void 0)
     return state.main?.killed || isQuotaExhausted(state.main?.quota, now) ? void 0 : "main";
   const fallback = routingAccountsOf(state).find((account) => account.id === assignment.accountId);
-  if (!fallback || fallback.enabled === !1 || fallback.killed === !0 || isQuotaExhausted(fallback.quota, now))
+  if (!fallback || fallback.enabled === !1 || fallback.routable === !1 || fallback.killed === !0 || isQuotaExhausted(fallback.quota, now))
     return;
   return fallback.id;
 }
 export function resolveSessionSidebarRouting(state, sessionId, now = Date.now()) {
-  if (!sessionId)
-    return { activeId: state.activeId ?? "main", route: state.route };
+  if (!sessionId) {
+    if (state.vaultAccounts === void 0)
+      return { activeId: state.activeId ?? "main", route: state.route };
+    const active = state.vaultAccounts.find((account) => account.id === state.activeId && account.enabled && account.routable !== !1 && !account.killed);
+    if (active && !isQuotaExhausted(active.quota, now))
+      return { activeId: active.id, route: state.route };
+  }
   const own = sessionId ? state.activeRouting?.[sessionId] : void 0, accounts = routingAccountsOf(state), ownQuota = own?.activeId === "main" ? state.main.quota : accounts.find((account) => account.id === own?.activeId)?.quota;
-  if (own && isUsableRoutingEntry(own, accounts, now) && !isQuotaExhausted(ownQuota, now))
+  if (own && (state.vaultAccounts === void 0 || own.activeId.startsWith("vault:")) && isUsableRoutingEntry(own, accounts, now) && !isQuotaExhausted(ownQuota, now))
     return { activeId: own.activeId, route: own.route };
   const stickyAccountId = resolveSessionStickyAccount(state, sessionId, now);
   if (stickyAccountId)
     return { activeId: stickyAccountId, route: state.route };
-  const vaultMode = state.vaultAccounts !== void 0, enabledFallbacks = (vaultMode ? state.vaultAccounts ?? [] : state.fallbacks).filter((account) => account.enabled && !account.killed), fallback = enabledFallbacks.find((account) => !isQuotaExhausted(account.quota, now)) ?? enabledFallbacks[0];
+  const vaultMode = state.vaultAccounts !== void 0, enabledFallbacks = (vaultMode ? vaultAccountsInPlacementOrder(state) : state.fallbacks).filter((account) => account.enabled && account.routable !== !1 && !account.killed), fallback = enabledFallbacks.find((account) => !isQuotaExhausted(account.quota, now)) ?? enabledFallbacks[0];
   return {
-    activeId: (vaultMode || state.route === "fallback-first") && fallback ? fallback.id : "main",
+    activeId: vaultMode ? fallback?.id ?? "vault" : state.route === "fallback-first" && fallback ? fallback.id : "main",
     route: state.route
   };
 }
+function vaultAccountsInPlacementOrder(state) {
+  const accounts = state.vaultAccounts ?? [], byId = new Map(accounts.map((account) => [account.id, account]));
+  return orderForPlacement(accounts.map((account) => account.id), state.route === "sticky-balanced" ? "roster" : orderedPlacement(state.route), vaultMainRouteId(accounts) ?? "").flatMap((id) => {
+    const account = byId.get(id);
+    return account ? [account] : [];
+  });
+}
 export function pruneActiveRouting(activeRouting, accounts, now = Date.now(), removedSessionId) {
   if (!activeRouting)
     return;
@@ -407,7 +427,14 @@ function writeMergedSidebarState(file, merge, hooks) {
     if (hooks?.canWrite && !hooks.canWrite())
       return;
     const next = merge(latest);
-    return next === void 0 ? void 0 : normalizeSidebarState(next);
+    if (next === void 0)
+      return;
+    if (next.vaultAccounts !== void 0) {
+      next.activeId = next.activeId?.startsWith("vault:") ? next.activeId : void 0;
+      next.activeRouting = Object.fromEntries(Object.entries(next.activeRouting ?? {}).filter(([, entry]) => entry.activeId.startsWith("vault:")));
+      next.stickyAssignments = Object.fromEntries(Object.entries(next.stickyAssignments ?? {}).filter(([, pin]) => pin.accountId.startsWith("vault:") && !next.vaultAccounts?.some((account) => account.id === pin.accountId && account.killed)));
+    }
+    return normalizeSidebarState(next);
   }, {
     beforeRecheck: async (...args) => {
       await hooks?.beforeRecheck?.(...args);
@@ -493,7 +520,7 @@ function mergeQuotaByWindow(incoming, existing) {
 export function setSidebarMachineState(machineState, file = getSidebarStateFile(), hooks) {
   return enqueueSidebarWrite(async () => {
     await writeMergedSidebarState(file, (latest) => {
-      const latestFallbacks = new Map(latest.fallbacks.map((account) => [account.id, account])), vaultMode = machineState.vaultAccounts !== void 0, mainSameIdentity = sameAccountIdentity(machineState.main.mainAccountId, latest.main.mainAccountId), mergedMainQuota = mainSameIdentity ? mergeQuotaByWindow(machineState.main.quota, latest.main.quota) : freshestQuota(machineState.main.quota, latest.main.quota), now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(routingAccountsOf(machineState)), now);
+      const latestFallbacks = new Map(latest.fallbacks.map((account) => [account.id, account])), vaultMode = machineState.vaultAccounts !== void 0, mainSameIdentity = sameAccountIdentity(machineState.main.mainAccountId, latest.main.mainAccountId), mergedMainQuota = mainSameIdentity ? mergeQuotaByWindow(machineState.main.quota, latest.main.quota) : freshestQuota(machineState.main.quota, latest.main.quota), now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, vaultMode ? void 0 : usableRoutingAccountIds(routingAccountsOf(machineState)), now);
       return {
         ...latest,
         ...machineState,
@@ -530,7 +557,7 @@ export function upsertSidebarActiveRouting(input, accounts, file = getSidebarSta
           route: input.route,
           updatedAt: input.updatedAt
         }
-      }, accounts, Date.now()), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(accounts), Date.now());
+      }, accounts, Date.now()), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, latest.vaultAccounts !== void 0 ? void 0 : usableRoutingAccountIds(accounts), Date.now());
       return {
         ...latest,
         activeId: input.activeId,
@@ -555,7 +582,7 @@ export function setSidebarLegacyRouting(input, file = getSidebarStateFile(), hoo
 export function removeSidebarActiveRouting(sessionId, accounts, file = getSidebarStateFile(), hooks) {
   return enqueueSidebarWrite(async () => {
     await writeMergedSidebarState(file, (latest) => {
-      const now = Date.now(), activeRouting = pruneActiveRouting(latest.activeRouting, accounts, now, sessionId), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, usableRoutingAccountIds(accounts), now, hashSidebarSessionId(sessionId));
+      const now = Date.now(), activeRouting = pruneActiveRouting(latest.activeRouting, accounts, now, sessionId), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, latest.vaultAccounts !== void 0 ? void 0 : usableRoutingAccountIds(accounts), now, hashSidebarSessionId(sessionId));
       return {
         ...latest,
         activeRouting,
@@ -652,7 +679,7 @@ export function persistSidebarStickyAssignment(input, file = getSidebarStateFile
   const sessionHash = hashSidebarSessionId(input.sessionId), validPinnedAccountIds = new Set(input.validPinnedAccountIds);
   return enqueueSidebarWrite(async () => {
     await writeMergedSidebarState(file, (latest) => {
-      const now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, validPinnedAccountIds, now), current = stickyAssignments?.[sessionHash];
+      const now = Date.now(), stickyAssignments = pruneStickyAssignments(latest.stickyAssignments, latest.vaultAccounts !== void 0 ? void 0 : validPinnedAccountIds, now), current = stickyAssignments?.[sessionHash];
       if (current && current.assignedAt > input.assignment.assignedAt) {
         if (stickyAssignmentsEqual(latest.stickyAssignments, stickyAssignments))
           return;
@@ -875,7 +902,7 @@ export function createSidebarBookkeepingQueue(options) {
 export function resolveActiveAccount(state) {
   const activeId = state.activeId;
   if (state.vaultAccounts !== void 0) {
-    const enabled = state.vaultAccounts.filter((account) => account.enabled), vaultAccount = enabled.find((account) => account.id === activeId) ?? enabled[0];
+    const enabled = vaultAccountsInPlacementOrder(state).filter((account) => account.enabled && account.routable !== !1), vaultAccount = enabled.find((account) => account.id === activeId) ?? enabled[0];
     return vaultAccount ? {
       id: vaultAccount.id,
       name: vaultAccount.label ?? vaultAccount.id,

package/src/tui-compiled/raw/tui/command-dialogs.tsx

@@ -17,6 +17,7 @@ import type {
   ApplyResult,
   OpenDialogPayload,
 } from "../rpc/protocol.js"
+import { factLines, sectionTitle } from "./section-text.js"
 
 const log = createLogger('rpc-tui')
 
@@ -48,31 +49,8 @@ export function sectionListOptions(menu: Menu): DrawerOption[] {
   }))
 }
 
-function factLines(facts: Record<string, unknown> | undefined): string[] {
-  return Object.entries(facts ?? {}).map(
-    ([name, value]) =>
-      `${name}: ${typeof value === 'string' ? value : JSON.stringify(value)}`,
-  )
-}
-
-/** Read-only text is a category header; every option navigates or runs an action. */
+/** Every option navigates or runs an action; read-only context is in the title. */
 export function sectionOptions(section: Section): DrawerOption[] {
-  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: DrawerOption[] = [
     ...section.items
       .filter((item) => item.actions.length > 0)
@@ -91,15 +69,6 @@ export function sectionOptions(section: Section): DrawerOption[] {
     })),
     { title: 'Back', value: BACK },
   ]
-  const first = options[0]
-  if (first && header.length > 0) {
-    const category = first.category
-    const text = [...header, category].filter(Boolean).join('\n')
-    for (const option of options) {
-      if (option.category !== category) break
-      option.category = text
-    }
-  }
   return options
 }
 
@@ -200,7 +169,7 @@ function showSection(
   api.ui.dialog.setSize('xlarge')
   api.ui.dialog.replace(() => (
     <DialogSelect
-      title={section.title}
+      title={sectionTitle(section)}
       options={sectionOptions(section)}
       onSelect={(option) => {
         const value = String(option.value)

package/src/tui-compiled/raw/tui/section-text.js

@@ -0,0 +1,21 @@
+export function factLines(facts) {
+  return Object.entries(facts ?? {}).map(([name, value]) => `${name}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
+}
+export function sectionText(section) {
+  return [
+    ...section.lines,
+    ...factLines(section.facts),
+    ...section.items.filter((item) => item.actions.length === 0).map((item) => [
+      item.group,
+      [item.label, item.status].filter(Boolean).join(" \xB7 "),
+      item.detail,
+      ...factLines(item.facts)
+    ].filter(Boolean).join(`
+`))
+  ].filter(Boolean).join(`
+`);
+}
+export function sectionTitle(section) {
+  return [section.title, sectionText(section)].filter(Boolean).join(`
+`);
+}

package/src/tui-compiled/raw/tui/v2-dialog.js

@@ -0,0 +1,137 @@
+import { sectionText, sectionTitle } from "./section-text.js";
+function inlineDescription(...parts) {
+  return parts.filter(Boolean).join(" \xB7 ").replace(/\r?\n/g, " \xB7 ");
+}
+export async function openControlDialog(dialog, initial, apply, active = () => !0) {
+  let payload = initial;
+  menu:
+    while (active()) {
+      const sectionId = await dialog.select({
+        title: payload.menu.title,
+        options: payload.menu.sections.map((section) => ({
+          title: section.title,
+          value: section.id,
+          description: inlineDescription(...section.lines)
+        }))
+      });
+      if (!active() || sectionId === void 0)
+        return;
+      const section = payload.menu.sections.find((entry) => entry.id === sectionId);
+      if (!section)
+        return;
+      const choices = [
+        ...section.items.filter((item) => item.actions.length > 0).map((item) => ({
+          title: item.label,
+          description: inlineDescription(item.status, item.detail),
+          value: { itemId: item.id, actions: item.actions }
+        })),
+        ...section.actions.map((action) => ({
+          title: action.label,
+          description: inlineDescription(action.description),
+          value: { itemId: void 0, actions: [action] }
+        }))
+      ];
+      if (choices.length === 0) {
+        await dialog.alert({
+          title: section.title,
+          message: sectionText(section)
+        });
+        continue;
+      }
+      const choice = await dialog.select({
+        title: sectionTitle(section),
+        options: [...choices, { title: "Back", value: void 0 }]
+      });
+      if (!active())
+        return;
+      if (!choice)
+        continue;
+      let actionId;
+      if (choice.itemId !== void 0) {
+        if (choice.actions.length === 0)
+          continue;
+        actionId = await dialog.select({
+          title: section.items.find((item) => item.id === choice.itemId)?.label ?? section.title,
+          options: [
+            ...choice.actions.map((action) => ({
+              title: action.label,
+              value: action.id
+            })),
+            { title: "Back", value: void 0 }
+          ]
+        });
+      } else
+        actionId = choice.actions[0]?.id;
+      if (!active())
+        return;
+      if (actionId === void 0)
+        continue;
+      const action = choice.actions.find((entry) => entry.id === actionId);
+      if (!action)
+        continue;
+      try {
+        const values = {};
+        for (const knob of action.knobs) {
+          let value;
+          if (knob.kind === "choice")
+            value = await dialog.select({
+              title: knob.label,
+              options: knob.choices.map((entry) => ({
+                title: entry.label,
+                value: entry.value
+              }))
+            });
+          else if (knob.kind === "toggle")
+            value = await dialog.select({
+              title: knob.label,
+              options: [
+                { title: `On${knob.value ? " (current)" : ""}`, value: !0 },
+                { title: `Off${!knob.value ? " (current)" : ""}`, value: !1 }
+              ]
+            });
+          else {
+            const text = await dialog.prompt({
+              title: knob.label,
+              ...knob.value !== void 0 ? { value: String(knob.value) } : {},
+              ...knob.kind === "text" && knob.placeholder ? { placeholder: knob.placeholder } : {}
+            });
+            value = text === void 0 ? void 0 : text === "" ? null : knob.kind === "number" && Number.isFinite(Number(text)) ? Number(text) : text;
+          }
+          if (!active())
+            return;
+          if (value === void 0)
+            continue menu;
+          values[knob.id] = value;
+        }
+        if (action.confirm) {
+          const confirmed = await dialog.confirm({
+            title: action.label,
+            message: action.confirm.message
+          });
+          if (!active())
+            return;
+          if (confirmed !== !0)
+            continue;
+        }
+        const result = await apply({
+          command: payload.command,
+          sectionId,
+          actionId,
+          ...choice.itemId !== void 0 ? { itemId: choice.itemId } : {},
+          ...action.knobs.length ? { values } : {},
+          ...action.confirm ? { confirmed: !0 } : {}
+        });
+        if (!active())
+          return;
+        payload = { command: result.command, menu: result.menu };
+        await dialog.alert({ title: payload.menu.title, message: result.text });
+      } catch (error) {
+        if (!active())
+          return;
+        await dialog.alert({
+          title: payload.menu.title,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+}

package/src/tui-compiled/raw/tui/v2.tsx

@@ -0,0 +1,133 @@
+/** @jsxImportSource @opentui/solid */
+import type { Plugin } from "@opencode/plugin/tui"
+import type { JSX } from "solid-js"
+import {
+  type ApplyRequest,
+  type ApplyResult,
+  isNotifyPayload,
+  type OpenDialogPayload,
+} from "../rpc/protocol.js"
+import { createRpcClient } from "../rpc/rpc-client.js"
+import { resolveRpcDir } from "../rpc/rpc-dir.js"
+import { openControlDialog } from "./v2-dialog.js"
+
+export interface TuiTransportOptions {
+  /** Test-only label for proving that the host can render a sidebar component. */
+  sidebarText?: string
+  sidebar?: {
+    render(input: { sessionID: string }): JSX.Element
+    dispose(): void
+  }
+  openDialog?: (
+    payload: OpenDialogPayload,
+    apply: (request: Omit<ApplyRequest, 'sessionId'>) => Promise<ApplyResult>,
+  ) => Promise<void>
+}
+
+const KEY = Symbol.for('cortexkit.openai-auth.v2.tui')
+type Mount = { dispose(): void }
+type State = { mount?: Mount; lastIds: Map<string, number> }
+
+/** Uses OpenCode 2's transport without running the OpenCode 1 UI registration. */
+export async function setupTui(
+  context: Plugin.Context,
+  options: TuiTransportOptions = {},
+) {
+  const processState = globalThis as typeof globalThis & { [KEY]?: State }
+  processState[KEY] ??= { lastIds: new Map() }
+  const state = processState[KEY]
+  state.mount?.dispose()
+  const openDialog: NonNullable<TuiTransportOptions['openDialog']> =
+    options.openDialog ??
+    ((payload, apply) =>
+      openControlDialog(context.ui.dialog, payload, apply, () => !disposed))
+  let disposed = false
+  let inFlight = false
+  let dialogOpen = false
+  let directory = ''
+  let client: ReturnType<typeof createRpcClient> | undefined
+  const unmount =
+    options.sidebarText === undefined
+      ? options.sidebar
+        ? context.ui.slot({
+            append: 'sidebar.content',
+            render: options.sidebar.render,
+          })
+        : undefined
+      : context.ui.slot({
+          append: 'sidebar.content',
+          render: () => <text>{options.sidebarText}</text>,
+        })
+
+  const poll = async () => {
+    if (disposed || inFlight || dialogOpen) return
+    const route = context.ui.router.current()
+    if (route.type !== 'session') return
+    const sessionId = route.sessionID
+    const session = context.data.session.get(sessionId)
+    if (!session) return
+    inFlight = true
+    try {
+      if (directory !== session.location.directory) {
+        directory = session.location.directory
+        const resolved = await resolveRpcDir(directory)
+        if (disposed) return
+        client = createRpcClient(resolved.dir, process.pid)
+      }
+      const rpc = client
+      if (!rpc) return
+      const messages = await rpc.pending(
+        state.lastIds.get(sessionId) ?? 0,
+        sessionId,
+      )
+      if (
+        disposed ||
+        context.ui.router.current().type !== 'session' ||
+        (context.ui.router.current() as { sessionID?: string }).sessionID !==
+          sessionId
+      )
+        return
+      for (const message of [...messages].sort((a, b) => a.id - b.id)) {
+        state.lastIds.set(
+          sessionId,
+          Math.max(state.lastIds.get(sessionId) ?? 0, message.id),
+        )
+        if (isNotifyPayload(message.payload))
+          context.ui.toast.show({
+            message: message.payload.notify.message,
+            sessionID: sessionId,
+          })
+        else {
+          dialogOpen = true
+          await openDialog(message.payload, (request) => {
+            if (disposed) throw new Error('The OpenAI dialog was closed')
+            return rpc.apply({ ...request, sessionId }, 90_000)
+          }).finally(() => {
+            dialogOpen = false
+          })
+        }
+      }
+    } catch {
+      // The server can be absent while a location starts or is reloaded.
+    } finally {
+      inFlight = false
+    }
+  }
+  const timer = setInterval(() => {
+    void poll()
+  }, 500)
+  const mount: Mount = {
+    dispose() {
+      if (disposed) return
+      disposed = true
+      clearInterval(timer)
+      unmount?.()
+      options.sidebar?.dispose()
+      if (dialogOpen) context.ui.dialog.clear()
+      if (state.mount === mount) state.mount = undefined
+    },
+  }
+  state.mount = mount
+  void poll()
+  return () => mount.dispose()
+}