@cortexkit/opencode-openai-auth 0.7.2 → 0.9.0

package/dist/tui.d.ts

@@ -1,35 +1,58 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPluginModule } from '@opencode-ai/plugin/tui';
-import type { ApplyRequest, CommandModalName } from './rpc/protocol.js';
-import { type AccountQuota, type QuotaPacing, type QuotaWindow, type SidebarState } from './sidebar-state.js';
+import { a as CommandModalName, r as ApplyRequest } from "./internal-Y7QNVDJT.js";
+import { b as SidebarState, c as QuotaPacing, l as QuotaWindow, r as AccountQuota, x as SpendControlReading } from "./sidebar-state-B98sERYt.js";
+import "./rpc/protocol.js";
+import { TuiPluginModule } from "@opencode-ai/plugin/tui";
+//#region src/tui.d.ts
 export declare function buildApplyRequest(command: CommandModalName, arguments_: string, sessionId?: string): ApplyRequest;
 type Tone = 'ok' | 'warn' | 'err' | 'muted' | 'accent' | 'text';
 export declare function formatResetIn(resetsAt: string | undefined): string;
 export interface QuotaDisplayRow {
-    key: 'primary' | 'secondary';
-    label: string;
-    window: QuotaWindow;
-    pacing: QuotaPacing | null;
+  key: 'primary' | 'secondary' | 'spendControl';
+  label: string;
+  labelWidth: number;
+  window: QuotaWindow;
+  pacing: QuotaPacing | null;
 }
-export declare function buildQuotaRowsForDisplay(quota: AccountQuota | null, now: number, pacingEnabled: boolean): QuotaDisplayRow[];
+/**
+ * Every quota the sidebar will draw, in one list.
+ *
+ * The label column is shared by all of them, so the width has to be measured
+ * over this exact set — measuring a subset is what made stacked accounts
+ * disagree about where the bar starts. Named rather than inlined at each call
+ * site because the set is the part that can be got wrong, and a call site
+ * cannot be tested without the host's rendering runtime.
+ */
+export declare function renderedQuotas(state: {
+  main?: {
+    quota?: AccountQuota | null;
+  } | null;
+  fallbacks?: ReadonlyArray<{
+    enabled?: boolean;
+    quota?: AccountQuota | null;
+  }>;
+}): ReadonlyArray<AccountQuota | null | undefined>;
+export declare function computeQuotaLabelWidth(quotas: ReadonlyArray<AccountQuota | null | undefined>): number;
+export declare function buildQuotaRowsForDisplay(quota: AccountQuota | null, now: number, pacingEnabled: boolean, labelWidth?: number): QuotaDisplayRow[];
 export declare function isQuotaLoaded(quota: AccountQuota | null): boolean;
 export declare function getQuotaMetadataRows(state: SidebarState): Array<{
-    label: string;
-    value: string;
+  label: string;
+  value: string;
 }>;
-export declare function getAccountMetadataRows(resetCredits: number | undefined): Array<{
-    label: string;
-    value: string;
+export declare function formatSpendControlAmounts(spendControl: SpendControlReading): string;
+export declare function getAccountMetadataRows(resetCredits: number | undefined, spendControl?: SpendControlReading): Array<{
+  label: string;
+  value: string;
 }>;
 export declare function readStateFromFile(): Promise<SidebarState>;
 export declare function resolveQuotaDialogActiveId(state: SidebarState, sessionId: string | undefined, now?: number): string | undefined;
 export interface RoutingDisplayRow {
-    label: string;
-    value: string;
-    tone: Tone;
+  label: string;
+  value: string;
+  tone: Tone;
 }
 export declare function buildRoutingRowsForDisplay(state: SidebarState, sessionId: string | undefined, now?: number): RoutingDisplayRow[];
 declare const plugin: TuiPluginModule & {
-    id: string;
+  id: string;
 };
-export default plugin;
+//#endregion
+export { plugin as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-openai-auth",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -10,9 +10,6 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "openai-auth": "./dist/cli.js"
-  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -36,22 +33,15 @@
   },
   "files": [
     "dist",
-    "src/tui.tsx",
-    "src/tui",
+    "src/tui/entry.mjs",
     "src/tui-compiled",
-    "src/sidebar-state.ts",
-    "src/tui-preferences.ts",
-    "src/logger.ts",
-    "src/core/account-paths.ts",
-    "src/core/refresh-file-lock.ts",
-    "src/util",
-    "src/rpc",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "rm -rf dist && bun build src/index.ts src/cli.ts src/sidebar-state.ts src/tui-preferences.ts src/rpc/rpc-client.ts src/rpc/port-file.ts src/rpc/protocol.ts src/rpc/rpc-dir.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --minify && tsc -p tsconfig.build.json --emitDeclarationOnly && bun run build:tui",
+    "build": "rm -rf dist && bun build src/index.ts src/sidebar-state.ts src/tui-preferences.ts src/rpc/rpc-client.ts src/rpc/port-file.ts src/rpc/protocol.ts src/rpc/rpc-dir.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --minify && bun run build:types && bun run build:tui",
     "build:tui": "bun scripts/build-tui.ts",
+    "build:types": "cd ../core && bun run build && cd ../opencode && tsdown --config tsdown.config.ts",
     "build:dev": "rm -rf dist && tsc -p tsconfig.build.json",
     "test": "bun test src/tests",
     "typecheck": "tsc",
@@ -61,7 +51,11 @@
   "peerDependencies": {
     "@opencode-ai/plugin": "*"
   },
+  "devDependencies": {
+    "@cortexkit/openai-auth-core": "workspace:*"
+  },
   "dependencies": {
+    "@cortexkit/subc-client": "^0.8.1",
     "@opentui/core": ">=0.5.11",
     "@opentui/solid": ">=0.5.11",
     "ai": "^7.0.99",

package/src/tui/entry.mjs

@@ -22,12 +22,12 @@ try {
   }
   // Older hosts and bare Bun do not provide the virtual registry. Their source
   // loader still applies the Solid transform, so retain the raw TSX fallback.
-  mod = await import('../tui.tsx')
+  mod = await import('../tui-compiled/raw/tui.tsx')
 }
 
 if (!mod) {
   try {
-    mod = await import('../tui-compiled/tui.tsx')
+    mod = await import('../tui-compiled/runtime/tui.tsx')
   } catch (error) {
     console.error('OpenAI Auth compiled TUI failed to load', error)
     throw error

package/src/tui-compiled/{core/account-paths.ts → raw/core-account-paths.ts}

@@ -1,23 +1,28 @@
 import { realpathSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
+import {
+  ACCOUNT_FILE_NAME,
+  ACCOUNT_STATE_FILE_NAME,
+  type AccountPaths,
+  deriveStatePath,
+} from '../shared/internal.ts'
 
 /**
- * Where the account store lives.
+ * Where OpenCode's account store lives.
  *
- * This is the ONLY definition. It used to be duplicated verbatim in both
- * `accounts.ts` and `refresh-file-lock.ts`, because `accounts.ts` imports the
- * lock and the reverse import would have been a cycle. Two copies of a path
- * resolver is a bad trade for that: the lock and the write must agree on the
- * exact file, and if the copies ever drifted, a writer would take a lock on one
- * path while writing another — mutual exclusion silently lost on a file holding
- * credentials. Nothing would fail a test, since each copy works on its own.
+ * This is the ONLY definition of this host's resolution rules. The store code
+ * itself takes both paths as arguments and resolves nothing, so the lock and
+ * the write it guards can never disagree about which file they mean — a
+ * disagreement would lose mutual exclusion on a file holding credentials while
+ * every test still passed, since each side works on its own.
  *
- * This module imports nothing from either side, so both can depend on it.
+ * The file names come from the core so the two hosts cannot drift apart on what
+ * the store is called.
  */
 
-export const ACCOUNT_FILE_NAME = 'openai-auth.json'
-export const ACCOUNT_STATE_FILE_NAME = 'openai-auth-state.json'
+export type { AccountPaths }
+export { ACCOUNT_FILE_NAME, ACCOUNT_STATE_FILE_NAME, deriveStatePath }
 
 function getConfigDir() {
   if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
@@ -36,13 +41,6 @@ export function getAccountStoragePath() {
   )
 }
 
-/** Derive the state-file path from the config path without reading env vars. */
-export function deriveStatePath(configPath: string): string {
-  return basename(configPath) === ACCOUNT_FILE_NAME
-    ? join(dirname(configPath), ACCOUNT_STATE_FILE_NAME)
-    : `${configPath}.state.json`
-}
-
 function normalizePathForComparison(path: string, platform: NodeJS.Platform) {
   const resolved = resolve(path)
   return platform === 'win32' || platform === 'darwin'
@@ -101,3 +99,16 @@ export function getAccountStatePath(configPath = getAccountStoragePath()) {
   }
   return deriveStatePath(configPath)
 }
+
+/**
+ * Both file paths a store call needs, resolved the way this host resolves them.
+ *
+ * Every call site that used to pass a single config path and let the store
+ * derive the state path now passes this pair instead, so the state-file
+ * override keeps being honoured in exactly the places it was before.
+ */
+export function getAccountPaths(
+  configPath = getAccountStoragePath(),
+): AccountPaths {
+  return { configPath, statePath: getAccountStatePath(configPath) }
+}

package/src/tui-compiled/raw/core-custody-state.ts

@@ -0,0 +1,243 @@
+export type CustodyMode = 'local' | 'claustrum'
+
+export type ManifestCustodyState = 'absent' | 'present' | 'unreadable'
+
+export type LocalCustodyState =
+  | 'real'
+  | 'tombstone'
+  | 'empty'
+  | 'gone'
+  | 'slot-absent'
+
+export type VaultCustodyState =
+  | 'serves'
+  | 'cold'
+  | 'needs_reauth'
+  | 'identity_mismatch'
+  | 'no_handle'
+
+export const CUSTODY_INERT_REASONS = [
+  'needs-login',
+  'mode-mismatch',
+  'corrupt-under-binding',
+  'manifest-unreadable',
+  'unbound-under-claustrum',
+  'orphan-tombstone',
+  'vault-cold',
+  'vault-reauth',
+  'identity-mismatch',
+  'no-handle',
+  'takeover-incomplete',
+  'new-local-family-under-claustrum',
+  'takeover-incomplete/vault-unavailable',
+  'takeover-incomplete/slot-absent',
+] as const
+
+export type CustodyInertReason = (typeof CUSTODY_INERT_REASONS)[number]
+
+export type CustodyVerdict =
+  | { kind: 'LOCAL' }
+  | {
+      kind: 'VAULT'
+      canonicalize?: boolean
+      installTombstone?: boolean
+    }
+  | {
+      kind: 'INERT'
+      reason: CustodyInertReason
+      installTombstone?: boolean
+      canonicalize?: boolean
+    }
+  | { kind: 'NEEDS_LOGIN'; reason?: 'corrupt' }
+
+export interface EvaluateCustodyStartupInput {
+  mode: CustodyMode
+  manifest: ManifestCustodyState
+  local: LocalCustodyState
+  vault: () => VaultCustodyState
+  manifestFailureReason?: string
+  fingerprintMatch?: boolean
+  verifiedInProcessLogin: boolean
+  isMain?: boolean
+}
+
+function unreachable(value: never): never {
+  return value
+}
+
+function withCanonicalization<
+  T extends Extract<CustodyVerdict, { kind: 'VAULT' | 'INERT' }>,
+>(local: LocalCustodyState, verdict: T): T | (T & { canonicalize: true }) {
+  return local === 'empty' ? { ...verdict, canonicalize: true } : verdict
+}
+
+function evaluateLocal(local: LocalCustodyState): CustodyVerdict {
+  switch (local) {
+    case 'real':
+      return { kind: 'LOCAL' }
+    case 'tombstone':
+    case 'empty':
+    case 'slot-absent':
+      return { kind: 'NEEDS_LOGIN' }
+    case 'gone':
+      return { kind: 'NEEDS_LOGIN', reason: 'corrupt' }
+  }
+  return unreachable(local)
+}
+
+function evaluateLocalWithBinding(
+  local: LocalCustodyState,
+  verifiedInProcessLogin: boolean,
+): CustodyVerdict {
+  switch (local) {
+    case 'real':
+      return verifiedInProcessLogin
+        ? { kind: 'LOCAL' }
+        : { kind: 'INERT', reason: 'needs-login' }
+    case 'tombstone':
+    case 'empty':
+    case 'slot-absent':
+      return { kind: 'INERT', reason: 'mode-mismatch' }
+    case 'gone':
+      return { kind: 'INERT', reason: 'corrupt-under-binding' }
+  }
+  return unreachable(local)
+}
+
+function evaluateUnboundClaustrum(local: LocalCustodyState): CustodyVerdict {
+  switch (local) {
+    case 'tombstone':
+    case 'empty':
+      return { kind: 'INERT', reason: 'orphan-tombstone' }
+    case 'real':
+    case 'gone':
+    case 'slot-absent':
+      return { kind: 'INERT', reason: 'unbound-under-claustrum' }
+  }
+  return unreachable(local)
+}
+
+function evaluateTombstone(
+  local: Extract<LocalCustodyState, 'tombstone' | 'empty'>,
+  vault: VaultCustodyState,
+): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return withCanonicalization(local, { kind: 'VAULT' })
+    case 'cold':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'vault-cold',
+      })
+    case 'needs_reauth':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'vault-reauth',
+      })
+    case 'identity_mismatch':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'identity-mismatch',
+      })
+    case 'no_handle':
+      return withCanonicalization(local, { kind: 'INERT', reason: 'no-handle' })
+  }
+  return unreachable(vault)
+}
+
+function evaluateReal(
+  vault: VaultCustodyState,
+  fingerprintMatch: boolean | undefined,
+): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return fingerprintMatch === false
+        ? { kind: 'INERT', reason: 'new-local-family-under-claustrum' }
+        : { kind: 'INERT', reason: 'takeover-incomplete' }
+    case 'cold':
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'takeover-incomplete/vault-unavailable' }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluateGone(vault: VaultCustodyState): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return { kind: 'VAULT', installTombstone: true }
+    case 'cold':
+      return { kind: 'INERT', reason: 'vault-cold', installTombstone: true }
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'vault-reauth', installTombstone: true }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluateSlotAbsent(vault: VaultCustodyState): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+    case 'cold':
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'takeover-incomplete/slot-absent' }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluatePresentClaustrum(
+  local: LocalCustodyState,
+  vault: VaultCustodyState,
+  fingerprintMatch: boolean | undefined,
+): CustodyVerdict {
+  switch (local) {
+    case 'tombstone':
+    case 'empty':
+      return evaluateTombstone(local, vault)
+    case 'real':
+      return evaluateReal(vault, fingerprintMatch)
+    case 'gone':
+      return evaluateGone(vault)
+    case 'slot-absent':
+      return evaluateSlotAbsent(vault)
+  }
+  return unreachable(local)
+}
+
+export function evaluateCustodyStartup(
+  input: EvaluateCustodyStartupInput,
+): CustodyVerdict {
+  if (input.manifest === 'unreadable') {
+    return { kind: 'INERT', reason: 'manifest-unreadable' }
+  }
+
+  switch (input.mode) {
+    case 'local':
+      return input.manifest === 'present'
+        ? evaluateLocalWithBinding(input.local, input.verifiedInProcessLogin)
+        : evaluateLocal(input.local)
+    case 'claustrum':
+      if (input.manifest === 'absent') {
+        return evaluateUnboundClaustrum(input.local)
+      }
+      if (input.manifest === 'present') {
+        return evaluatePresentClaustrum(
+          input.local,
+          input.vault(),
+          input.fingerprintMatch,
+        )
+      }
+      return unreachable(input.manifest)
+  }
+  return unreachable(input.mode)
+}

package/src/tui-compiled/raw/logger.ts

@@ -0,0 +1,53 @@
+/**
+ * OpenCode's log destination.
+ *
+ * The logger itself lives in the shared core so both hosts get the same
+ * redaction rules. What stays here is the part that is specific to this host:
+ * which file the lines go to, which level floor applies, and when the buffer is
+ * drained at process exit. Those are the only three things that read this
+ * host's environment variables, and the core reads none.
+ *
+ * The init runs at module load rather than from one call site because every
+ * entry point in this package — the plugin loader, the RPC server, the separate
+ * TUI process — reaches the logger through this module, and a core logger no
+ * host has initialised silently drops every line. Both values are passed as
+ * functions so the destination and level keep resolving on each write, which is
+ * what they do today.
+ */
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  flushLogs,
+  initLogger,
+  type Level,
+} from '../shared/internal.ts'
+
+export {
+  createLogger,
+  flushForTest,
+  flushLogs,
+  type Level,
+  redact,
+  redactStrings,
+  setLogLevel,
+} from '../shared/internal.ts'
+
+const LEVELS: readonly Level[] = ['error', 'warn', 'info', 'debug', 'trace']
+
+export function getLogFile(): string {
+  return (
+    process.env.OPENCODE_OPENAI_AUTH_LOG_FILE ??
+    join(tmpdir(), 'opencode-openai-auth.log')
+  )
+}
+
+export function getEnvLogLevel(): Level | undefined {
+  const env = process.env.OPENCODE_OPENAI_AUTH_LOG_LEVEL as Level | undefined
+  return env && LEVELS.includes(env) ? env : undefined
+}
+
+initLogger({ file: getLogFile, level: getEnvLogLevel })
+
+// Under `bun test` the buffer is drained explicitly by the tests that assert on
+// it, and registering a process-wide exit handler per test file is noise.
+if (process.env.NODE_ENV !== 'test') process.on('exit', flushLogs)

package/src/tui-compiled/{rpc/port-file.ts → raw/rpc-port-file.ts}

@@ -10,7 +10,7 @@ import {
   writeFile,
 } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
-import { createLogger } from '../logger'
+import { createLogger } from './logger.ts'
 
 const log = createLogger('rpc')
 

package/src/tui-compiled/raw/rpc-protocol.ts

@@ -0,0 +1,12 @@
+/**
+ * The RPC payload types now live in the shared core, because both hosts build
+ * the same payloads. This file stays on disk as a re-export so the existing
+ * build entry and every importer that names `rpc/protocol` keep working.
+ */
+export type {
+  ApplyRequest,
+  ApplyResult,
+  CommandModalName,
+  OpenDialogPayload,
+  RpcNotification,
+} from '../shared/internal.ts'

package/src/{rpc/rpc-client.ts → tui-compiled/raw/rpc-rpc-client.ts}

@@ -1,5 +1,5 @@
-import { discoverPortFile, type PortFileEntry } from './port-file'
-import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol'
+import { discoverPortFile, type PortFileEntry } from './rpc-port-file.ts'
+import type { ApplyRequest, ApplyResult, RpcNotification } from './rpc-protocol.ts'
 
 export interface RpcClient {
   pending: (