@cortexkit/opencode-anthropic-auth 1.14.0 → 1.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-anthropic-auth",
-  "version": "1.14.0",
+  "version": "1.15.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -16,7 +16,7 @@
     },
     "./tui": {
       "types": "./dist/tui.d.ts",
-      "import": "./src/tui.tsx"
+      "import": "./src/tui/entry.mjs"
     },
     "./tui-prefs": {
       "types": "./dist/tui-preferences.d.ts",
@@ -36,7 +36,8 @@
   "files": [
     "dist",
     "src/tui.tsx",
-    "src/tui/command-dialogs.tsx",
+    "src/tui",
+    "src/tui-compiled",
     "src/sidebar-state.ts",
     "src/tui-preferences.ts",
     "src/rpc",
@@ -44,24 +45,26 @@
     "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",
+    "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:tui": "bun scripts/build-tui.ts",
+    "smoke:tui": "bun scripts/smoke-tui-pack-install.ts",
     "build:dev": "rm -rf dist && tsc -p tsconfig.build.json",
     "dev": "bun ../../scripts/dev.ts",
     "dev:clean": "bun ../../scripts/dev-clean.ts",
     "extract": "bun ../../scripts/extract-system-prompt.ts",
     "test": "bun test src/tests",
-    "typecheck": "tsc",
-    "types": "tsc",
+    "typecheck": "tsc && tsc -p tsconfig.scripts.json",
+    "types": "tsc && tsc -p tsconfig.scripts.json",
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": "*"
   },
   "dependencies": {
-    "@cortexkit/anthropic-auth-core": "1.14.0",
-    "@opentui/core": ">=0.4.2",
-    "@opentui/solid": ">=0.4.3",
+    "@cortexkit/anthropic-auth-core": "1.15.1",
+    "@opentui/core": "0.4.3",
+    "@opentui/solid": "0.4.3",
     "jsonc-parser": "^3.3.1",
-    "solid-js": "^1.9.10"
+    "solid-js": "1.9.12"
   }
 }

package/src/sidebar-state.ts

@@ -27,6 +27,13 @@ export interface SidebarAccountState {
   needsReauth: boolean
 }
 
+export interface FableRecoverySidebarState {
+  sessionId: string
+  mode: 'opus' | 'fable'
+  remaining: number
+  changedAt: number
+}
+
 export interface SidebarState {
   main: {
     quota: AccountQuota | null
@@ -45,6 +52,7 @@ export interface SidebarState {
     window?: string
     trackedSessions?: number
   }
+  fableRecoveries?: FableRecoverySidebarState[]
   lastUpdated: number
 }
 
@@ -185,6 +193,32 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
     }
   }
 
+  const fableRecoveries: FableRecoverySidebarState[] = Array.isArray(
+    raw.fableRecoveries,
+  )
+    ? raw.fableRecoveries
+        .filter(isRecord)
+        .flatMap((recovery): FableRecoverySidebarState[] => {
+          if (
+            typeof recovery.sessionId !== 'string' ||
+            (recovery.mode !== 'opus' && recovery.mode !== 'fable') ||
+            typeof recovery.remaining !== 'number' ||
+            !Number.isFinite(recovery.remaining) ||
+            typeof recovery.changedAt !== 'number' ||
+            !Number.isFinite(recovery.changedAt)
+          )
+            return []
+          return [
+            {
+              sessionId: recovery.sessionId,
+              mode: recovery.mode,
+              remaining: Math.max(0, Math.floor(recovery.remaining)),
+              changedAt: recovery.changedAt,
+            },
+          ]
+        })
+    : []
+
   return {
     main,
     fallbacks,
@@ -197,6 +231,7 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
         ? raw.fastMode
         : DEFAULT_SIDEBAR_STATE.fastMode,
     cacheKeep,
+    fableRecoveries: fableRecoveries.length > 0 ? fableRecoveries : undefined,
     lastUpdated: typeof raw.lastUpdated === 'number' ? raw.lastUpdated : 0,
   }
 }
@@ -265,6 +300,18 @@ export function formatScopedQuotaLabel(title: string) {
   return /^fable$/i.test(label) ? 'Fa' : label
 }
 
+export function getFableRecoverySummary(
+  state: SidebarState,
+  sessionId: string,
+): string | undefined {
+  const recovery = state.fableRecoveries?.find(
+    (candidate) => candidate.sessionId === sessionId,
+  )
+  if (!recovery) return undefined
+  if (recovery.mode === 'fable') return 'Fable 5 · restored'
+  return `Opus 4.8 · ${recovery.remaining} left`
+}
+
 export function getCollapsedQuotaSummary(quota: AccountQuota | null): {
   fiveHourUsedPercent: number | null
   sevenDayUsedPercent: number | null

package/src/tui/entry.mjs

@@ -0,0 +1,37 @@
+// Prefer the host OpenTUI runtime registry when it exists. OpenTUI 0.4.x
+// registers these virtual modules process-wide, allowing the precompiled TUI to
+// share the host's single Solid/OpenTUI runtime when loaded from node_modules.
+const runtimeProbe = `opentui:runtime-module:${encodeURIComponent('@opentui/solid')}`
+
+function isMissingRuntimeRegistry(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    /Cannot find|Could not resolve|Module not found|Unable to resolve/.test(
+      message,
+    ) && message.includes('opentui:runtime-module:')
+  )
+}
+
+let mod
+try {
+  await import(runtimeProbe)
+} catch (error) {
+  if (!isMissingRuntimeRegistry(error)) {
+    console.error('Anthropic Auth TUI runtime registry probe failed', error)
+    throw error
+  }
+  // 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')
+}
+
+if (!mod) {
+  try {
+    mod = await import('../tui-compiled/tui.tsx')
+  } catch (error) {
+    console.error('Anthropic Auth compiled TUI failed to load', error)
+    throw error
+  }
+}
+
+export default mod.default

package/src/tui-compiled/rpc/port-file.ts

@@ -0,0 +1,70 @@
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  unlink,
+  writeFile,
+} from 'node:fs/promises'
+import { join } from 'node:path'
+
+export interface PortFileEntry {
+  port: number
+  token: string
+  pid: number
+  startedAt: number
+}
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM'
+  }
+}
+
+export async function writePortFile(
+  dir: string,
+  entry: { port: number; token: string; pid: number },
+): Promise<string> {
+  await mkdir(dir, { recursive: true })
+  const full: PortFileEntry = { ...entry, startedAt: Date.now() }
+  const target = join(dir, `port-${entry.pid}.json`)
+  const tmp = `${target}.${process.pid}.tmp`
+  await writeFile(tmp, JSON.stringify(full), { encoding: 'utf8', mode: 0o600 })
+  await rename(tmp, target)
+  return target
+}
+
+export async function discoverPortFile(
+  dir: string,
+  expectedPid?: number,
+): Promise<PortFileEntry | null> {
+  let names: string[]
+  try {
+    names = await readdir(dir)
+  } catch {
+    return null
+  }
+  const live: PortFileEntry[] = []
+  for (const name of names) {
+    if (!name.startsWith('port-') || !name.endsWith('.json')) continue
+    try {
+      const parsed = JSON.parse(
+        await readFile(join(dir, name), 'utf8'),
+      ) as PortFileEntry
+      if (Number.isFinite(parsed.port)) {
+        if (pidAlive(parsed.pid)) live.push(parsed)
+        else unlink(join(dir, name)).catch(() => {})
+      }
+    } catch {}
+  }
+  if (live.length === 0) return null
+  const candidates =
+    expectedPid && expectedPid >= 1
+      ? live.filter((entry) => entry.pid === expectedPid)
+      : []
+  const entries = candidates.length > 0 ? candidates : live
+  return entries.sort((a, b) => b.startedAt - a.startedAt)[0] ?? null
+}

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

@@ -0,0 +1,34 @@
+export type CommandModalName =
+  | 'claude-account'
+  | 'claude-cache'
+  | 'claude-cachekeep'
+  | 'claude-quota'
+  | 'claude-dump'
+  | 'claude-fast'
+  | 'claude-routing'
+  | 'claude-killswitch'
+  | 'claude-logging'
+
+export interface OpenDialogPayload {
+  command: CommandModalName
+  text: string
+  knobs: Record<string, unknown>
+}
+
+export interface RpcNotification {
+  id: number
+  type: 'open-dialog'
+  payload: OpenDialogPayload
+  sessionId?: string
+}
+
+export interface ApplyRequest {
+  command: CommandModalName
+  arguments: string
+  sessionId?: string
+}
+
+export interface ApplyResult {
+  text: string
+  knobs: Record<string, unknown>
+}

package/src/tui-compiled/rpc/rpc-client.ts

@@ -0,0 +1,62 @@
+import { discoverPortFile } from './port-file'
+import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol'
+
+export interface RpcClient {
+  pending: (
+    lastReceivedId: number,
+    sessionId?: string,
+  ) => Promise<RpcNotification[]>
+  apply: (request: ApplyRequest) => Promise<ApplyResult>
+}
+
+async function call<T>(
+  dir: string,
+  method: string,
+  params: Record<string, unknown>,
+  expectedPid?: number,
+): Promise<T | null> {
+  const entry = await discoverPortFile(dir, expectedPid)
+  if (!entry) return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), 2_000)
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/rpc/${method}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${entry.token}`,
+      },
+      body: JSON.stringify(params),
+      signal: controller.signal,
+    })
+    if (!res.ok) return null
+    return (await res.json()) as T
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export function createRpcClient(dir: string, expectedPid?: number): RpcClient {
+  return {
+    async pending(lastReceivedId, sessionId) {
+      const out = await call<{ messages: RpcNotification[] }>(
+        dir,
+        'pending-notifications',
+        { lastReceivedId, sessionId },
+        expectedPid,
+      )
+      return out?.messages ?? []
+    },
+    async apply(request) {
+      const out = await call<ApplyResult>(
+        dir,
+        'apply',
+        { ...request },
+        expectedPid,
+      )
+      return out ?? { text: 'apply failed', knobs: {} }
+    },
+  }
+}

package/src/tui-compiled/rpc/rpc-dir.ts

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto'
+import { homedir, tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+const RPC_DIR_ENV = 'OPENCODE_ANTHROPIC_AUTH_RPC_DIR'
+
+// Both processes must resolve the SAME dir from the SAME project directory.
+export function getRpcDir(projectDirectory: string): string {
+  const override = process.env[RPC_DIR_ENV]?.trim()
+  if (override) return resolve(projectDirectory, override)
+  const hash = createHash('sha256')
+    .update(projectDirectory)
+    .digest('hex')
+    .slice(0, 16)
+  const base = process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state')
+  return join(base, 'cortexkit', 'anthropic-auth', 'rpc', hash)
+}
+
+export { tmpdir }