@cortexkit/opencode-anthropic-auth 1.21.0 → 1.23.0

package/src/rpc/notifications.ts

@@ -3,52 +3,56 @@ import type { OpenDialogPayload, RpcNotification } from './protocol'
 const QUEUE_CAP = 100
 const TUI_CONNECTED_WINDOW_MS = 3_000
 
+// One queue serves every RPC server in the process, and a process can hold one
+// server per project directory. Session ids are globally unique, so both
+// producers and drains require one: an unscoped drain could otherwise expose
+// another project's pending command dialog.
 let queue: RpcNotification[] = []
 let nextId = 1
-let lastDrainAtAny = 0
 const lastDrainAtBySession = new Map<string, number>()
 
+function assertSessionId(sessionId: string): void {
+  if (typeof sessionId !== 'string' || sessionId.length === 0) {
+    throw new TypeError('sessionId is required')
+  }
+}
+
 export function pushNotification(
   payload: OpenDialogPayload,
-  sessionId?: string,
+  sessionId: string,
 ): void {
+  assertSessionId(sessionId)
   queue.push({ id: nextId++, type: 'open-dialog', payload, sessionId })
   if (queue.length > QUEUE_CAP) queue = queue.slice(queue.length - QUEUE_CAP)
 }
 
 export function drainNotifications(
-  lastReceivedId = 0,
-  sessionId?: string,
+  lastReceivedId: number,
+  sessionId: string,
 ): RpcNotification[] {
-  const now = Date.now()
-  lastDrainAtAny = now
-  if (sessionId !== undefined) lastDrainAtBySession.set(sessionId, now)
-  const matches = (n: RpcNotification) =>
-    sessionId === undefined ||
-    n.sessionId === undefined ||
-    n.sessionId === sessionId
+  assertSessionId(sessionId)
+  lastDrainAtBySession.set(sessionId, Date.now())
   if (lastReceivedId > 0) {
-    queue = queue.filter((n) => {
-      if (n.id > lastReceivedId) return true
-      if (sessionId === undefined) return false
-      return n.sessionId !== sessionId
-    })
+    queue = queue.filter(
+      (notification) =>
+        notification.id > lastReceivedId ||
+        notification.sessionId !== sessionId,
+    )
   }
-  return queue.filter((n) => n.id > lastReceivedId && matches(n))
+  return queue.filter(
+    (notification) =>
+      notification.id > lastReceivedId && notification.sessionId === sessionId,
+  )
 }
 
-export function isTuiConnected(sessionId?: string): boolean {
+export function isTuiConnected(sessionId: string): boolean {
   const now = Date.now()
-  if (sessionId !== undefined) {
-    const at = lastDrainAtBySession.get(sessionId) ?? 0
-    return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS
-  }
-  return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS
+  const at = lastDrainAtBySession.get(sessionId) ?? 0
+  return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS
 }
 
 export function resetNotificationsForTest(): void {
   queue = []
   nextId = 1
-  lastDrainAtAny = 0
   lastDrainAtBySession.clear()
 }

package/src/rpc/protocol.ts

@@ -1,3 +1,5 @@
+import type { ClaustrumEnrollmentStatus } from '@cortexkit/anthropic-auth-core'
+
 export const COMMAND_MODAL_NAMES = [
   'claude-account',
   'claude-cache',
@@ -14,6 +16,37 @@ export const COMMAND_MODAL_NAMES = [
 
 export type CommandModalName = (typeof COMMAND_MODAL_NAMES)[number]
 
+export interface AccountDialogAccount {
+  id: string
+  label: string
+  role: 'main' | 'fallback'
+  enabled: boolean
+  quotaPercent: number | null
+  tierLabel?: string
+  claustrumGate: 'on' | 'off' | 'na'
+  vaultServed: boolean
+  vaultReauth: boolean
+  custodyState:
+    | 'na'
+    | 'off'
+    | 'on-vault-served'
+    | 'on-vault-reauth'
+    | 'on-cold'
+    | 'unknown-identity'
+    | 'on-identity-mismatch'
+    | 'on-corrupt-binding'
+}
+
+export interface AccountDialogKnobs {
+  accounts: AccountDialogAccount[]
+  claustrumDetection: string
+  custodyMode?: 'local' | 'claustrum'
+  custodyModeKnown?: boolean
+  enrollmentStatus?: string
+  claustrumEnrollment?: ClaustrumEnrollmentStatus
+  [key: string]: unknown
+}
+
 export interface OpenDialogPayload {
   command: CommandModalName
   text: string
@@ -24,7 +57,7 @@ export interface RpcNotification {
   id: number
   type: 'open-dialog'
   payload: OpenDialogPayload
-  sessionId?: string
+  sessionId: string
 }
 
 export interface ApplyRequest {

package/src/rpc/rpc-client.ts

@@ -4,7 +4,7 @@ import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol'
 export interface RpcClient {
   pending: (
     lastReceivedId: number,
-    sessionId?: string,
+    sessionId: string,
   ) => Promise<RpcNotification[]>
   apply: (request: ApplyRequest) => Promise<ApplyResult>
 }

package/src/rpc/rpc-server.ts

@@ -1,5 +1,5 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto'
-import { unlink } from 'node:fs/promises'
+import { readFile, unlink } from 'node:fs/promises'
 import {
   createServer,
   type IncomingMessage,
@@ -74,9 +74,15 @@ export async function startRpcServer(
         unknown
       >
       if (method === 'pending-notifications') {
+        if (
+          typeof params.sessionId !== 'string' ||
+          params.sessionId.length === 0
+        ) {
+          return json(400, { error: 'sessionId is required' })
+        }
         const messages = options.drain(
           Number(params.lastReceivedId ?? 0),
-          typeof params.sessionId === 'string' ? params.sessionId : undefined,
+          params.sessionId,
         )
         return json(200, { messages })
       }
@@ -115,9 +121,16 @@ export async function startRpcServer(
     token,
     async stop() {
       await new Promise<void>((resolve) => server.close(() => resolve()))
-      await unlink(join(options.dir, `port-${process.pid}.json`)).catch(
-        () => {},
-      )
+      try {
+        const portFile = join(options.dir, `port-${process.pid}.json`)
+        const current = JSON.parse(await readFile(portFile, 'utf8')) as {
+          port?: unknown
+          pid?: unknown
+        }
+        if (current.port === port && current.pid === process.pid) {
+          await unlink(portFile)
+        }
+      } catch {}
     },
   }
 }

package/src/rpc/server-registry.ts

@@ -0,0 +1,61 @@
+import type { RpcServerHandle } from './rpc-server'
+
+type RpcServerGlobal = typeof globalThis & {
+  __anthropicAuthRpcServers?: Map<string, RpcServerHandle>
+  __anthropicAuthRpcServersPending?: Map<string, Promise<void>>
+}
+
+export interface RpcServerAdoption {
+  server: RpcServerHandle
+  release: () => Promise<void>
+}
+
+/**
+ * Serializes same-directory replacement and returns an identity-fenced lease.
+ * Distinct project directories remain independent.
+ */
+export async function adoptRpcServer(
+  rpcDir: string,
+  create: () => Promise<RpcServerHandle>,
+): Promise<RpcServerAdoption> {
+  const rpcGlobal = globalThis as RpcServerGlobal
+  const servers =
+    rpcGlobal.__anthropicAuthRpcServers ?? new Map<string, RpcServerHandle>()
+  const pending =
+    rpcGlobal.__anthropicAuthRpcServersPending ??
+    new Map<string, Promise<void>>()
+  rpcGlobal.__anthropicAuthRpcServers = servers
+  rpcGlobal.__anthropicAuthRpcServersPending = pending
+
+  const predecessor = pending.get(rpcDir) ?? Promise.resolve()
+  let server: RpcServerHandle | undefined
+  const start = predecessor
+    .catch(() => {})
+    .then(async () => {
+      const previous = servers.get(rpcDir)
+      if (previous) {
+        await previous.stop()
+        if (servers.get(rpcDir) === previous) servers.delete(rpcDir)
+      }
+      server = await create()
+      servers.set(rpcDir, server)
+    })
+  pending.set(rpcDir, start)
+
+  try {
+    await start
+  } finally {
+    if (pending.get(rpcDir) === start) pending.delete(rpcDir)
+  }
+  const adoptedServer = server
+  if (!adoptedServer) throw new Error('RPC server failed to start')
+
+  return {
+    server: adoptedServer,
+    release: async () => {
+      if (servers.get(rpcDir) !== adoptedServer) return
+      await adoptedServer.stop()
+      if (servers.get(rpcDir) === adoptedServer) servers.delete(rpcDir)
+    },
+  }
+}

package/src/sidebar-state.ts

@@ -34,6 +34,18 @@ export interface SidebarAccountState {
   // True when the account's refresh token is permanently dead (400
   // invalid_grant) and it needs a re-login — distinct from a transient backoff.
   needsReauth: boolean
+  // True when the vault copy needs re-importing while the sidecar remains usable.
+  vaultReauth?: boolean
+  // A gate alone does not prove the sidecar can serve a request.
+  vaultServed?: boolean
+  custodyState?:
+    | 'off'
+    | 'on-vault-served'
+    | 'on-vault-reauth'
+    | 'on-cold'
+    | 'unknown-identity'
+    | 'on-identity-mismatch'
+    | 'on-corrupt-binding'
   tierLabel?: string
 }
 
@@ -57,7 +69,7 @@ export interface PrimeSidebarAccountState {
   label: string
   nextDueAt?: number | null
   lastPrimedAt?: number | null
-  lastResult?: 'ok' | 'error'
+  lastResult?: 'ok' | 'error' | 'skipped'
   usage?: PrimeUsageCounters
   estimatedCostUsd?: number
 }
@@ -178,7 +190,11 @@ function normalizePrimeAccount(
   } else if (isFiniteNumber(value.lastPrimedAt)) {
     account.lastPrimedAt = value.lastPrimedAt
   }
-  if (value.lastResult === 'ok' || value.lastResult === 'error') {
+  if (
+    value.lastResult === 'ok' ||
+    value.lastResult === 'error' ||
+    value.lastResult === 'skipped'
+  ) {
     account.lastResult = value.lastResult
   }
   const usage = normalizePrimeUsage(value.usage)
@@ -335,6 +351,12 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
           enabled: typeof entry.enabled === 'boolean' ? entry.enabled : false,
           needsReauth:
             typeof entry.needsReauth === 'boolean' ? entry.needsReauth : false,
+          ...(entry.vaultReauth === true && { vaultReauth: true }),
+          ...(entry.vaultServed === true && { vaultServed: true }),
+          ...(typeof entry.custodyState === 'string' && {
+            custodyState:
+              entry.custodyState as SidebarAccountState['custodyState'],
+          }),
           tierLabel:
             typeof entry.tierLabel === 'string' && entry.tierLabel.trim()
               ? entry.tierLabel.trim()
@@ -715,6 +737,8 @@ export async function setSidebarState(
               lastUpdated: Math.max(current.lastUpdated, state.lastUpdated),
             }
           }
+          // The state file is a cross-process artifact; future account fields must fail closed.
+          stateToWrite = normalizeSidebarState(stateToWrite)
           result = await writeSidebarStateAtomic(
             stateFile,
             stateToWrite,
@@ -795,13 +819,25 @@ export function formatScopedQuotaLabel(title: string) {
 }
 
 /**
- * Pretty label for a recoverable-refusal source model (Fable 5 or Opus 5).
+ * Pretty label for a recoverable-refusal source model (Fable 5/5.1 or Opus 5).
  * Falls back to the raw id for unrecognized ids so the sidebar never goes
  * blank on a future model that has not yet been cataloged here.
  */
 export function formatFallbackModelLabel(modelId: string | undefined): string {
+  if (
+    modelId === 'claude-mythos-5-1' ||
+    modelId?.startsWith('claude-mythos-5-1-')
+  )
+    return 'Mythos 5.1'
+  if (
+    modelId === 'claude-fable-5-1' ||
+    modelId?.startsWith('claude-fable-5-1-')
+  )
+    return 'Fable 5.1'
   if (modelId === 'claude-fable-5' || modelId?.startsWith('claude-fable-5-'))
     return 'Fable 5'
+  if (modelId === 'claude-opus-5-5' || modelId?.startsWith('claude-opus-5-5-'))
+    return 'Opus 5.5'
   if (modelId === 'claude-opus-5' || modelId?.startsWith('claude-opus-5-'))
     return 'Opus 5'
   if (modelId === 'claude-opus-4-8' || modelId?.startsWith('claude-opus-4-8-'))
@@ -829,6 +865,9 @@ export function formatPrimeAccountValue(account: PrimeSidebarAccountState): {
   if (account.lastResult === 'error') {
     return { text: 'err', hasError: true }
   }
+  if (account.lastResult === 'skipped') {
+    return { text: 'skip', hasError: false }
+  }
   if (account.nextDueAt && account.nextDueAt > Date.now()) {
     return { text: formatPrimeTime(account.nextDueAt), hasError: false }
   }