@cortexkit/opencode-anthropic-auth 1.10.3 → 1.12.0

package/src/rpc/protocol.ts

@@ -1,4 +1,5 @@
 export type CommandModalName =
+  | 'claude-account'
   | 'claude-cache'
   | 'claude-cachekeep'
   | 'claude-quota'
@@ -6,6 +7,7 @@ export type CommandModalName =
   | 'claude-fast'
   | 'claude-routing'
   | 'claude-killswitch'
+  | 'claude-logging'
 
 export interface OpenDialogPayload {
   command: CommandModalName
@@ -23,6 +25,7 @@ export interface RpcNotification {
 export interface ApplyRequest {
   command: CommandModalName
   arguments: string
+  sessionId?: string
 }
 
 export interface ApplyResult {

package/src/rpc/rpc-client.ts

@@ -13,8 +13,9 @@ async function call<T>(
   dir: string,
   method: string,
   params: Record<string, unknown>,
+  expectedPid?: number,
 ): Promise<T | null> {
-  const entry = await discoverPortFile(dir)
+  const entry = await discoverPortFile(dir, expectedPid)
   if (!entry) return null
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(), 2_000)
@@ -37,18 +38,24 @@ async function call<T>(
   }
 }
 
-export function createRpcClient(dir: string): RpcClient {
+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 })
+      const out = await call<ApplyResult>(
+        dir,
+        'apply',
+        { ...request },
+        expectedPid,
+      )
       return out ?? { text: 'apply failed', knobs: {} }
     },
   }

package/src/rpc/rpc-dir.ts

@@ -1,13 +1,13 @@
 import { createHash } from 'node:crypto'
 import { homedir, tmpdir } from 'node:os'
-import { join } from 'node:path'
+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 override
+  if (override) return resolve(projectDirectory, override)
   const hash = createHash('sha256')
     .update(projectDirectory)
     .digest('hex')

package/src/rpc/rpc-server.ts

@@ -86,9 +86,11 @@ export async function startRpcServer(
       }
       return json(404, { error: 'unknown method' })
     } catch (error) {
-      json(500, {
-        error: error instanceof Error ? error.message : String(error),
-      })
+      if (!res.headersSent && !res.writableEnded && !res.destroyed) {
+        json(500, {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
     }
   }
 

package/src/sidebar-state.ts

@@ -14,6 +14,9 @@ export interface SidebarAccountState {
   label: string | undefined
   quota: AccountQuota | null
   enabled: boolean
+  // 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
 }
 
 export interface SidebarState {
@@ -58,24 +61,109 @@ export const DEFAULT_SIDEBAR_STATE: SidebarState = {
   fastMode: false,
   lastUpdated: 0,
 }
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === 'object' && !Array.isArray(v)
+}
+
+export function normalizeSidebarState(raw: unknown): SidebarState {
+  if (!isRecord(raw)) return { ...DEFAULT_SIDEBAR_STATE }
+
+  const main: SidebarState['main'] = { quota: null }
+  if (isRecord(raw.main)) {
+    const m = raw.main
+    main.quota = isRecord(m.quota) ? (m.quota as AccountQuota) : null
+    if (typeof m.quotaBackedOff === 'boolean')
+      main.quotaBackedOff = m.quotaBackedOff
+    if (typeof m.quotaBackoffUntil === 'number')
+      main.quotaBackoffUntil = m.quotaBackoffUntil
+    if (typeof m.refreshBackedOff === 'boolean')
+      main.refreshBackedOff = m.refreshBackedOff
+    if (typeof m.refreshBackoffUntil === 'number')
+      main.refreshBackoffUntil = m.refreshBackoffUntil
+  }
+
+  const fallbacks: SidebarAccountState[] = Array.isArray(raw.fallbacks)
+    ? raw.fallbacks
+        .filter(isRecord)
+        .filter((entry) => typeof entry.id === 'string')
+        .map((entry) => ({
+          id: entry.id as string,
+          label: typeof entry.label === 'string' ? entry.label : undefined,
+          quota: isRecord(entry.quota) ? (entry.quota as AccountQuota) : null,
+          enabled: typeof entry.enabled === 'boolean' ? entry.enabled : false,
+          needsReauth:
+            typeof entry.needsReauth === 'boolean' ? entry.needsReauth : false,
+        }))
+    : []
+
+  let relay: SidebarState['relay'] = null
+  if (isRecord(raw.relay)) {
+    const r = raw.relay
+    if (typeof r.enabled === 'boolean' && typeof r.transport === 'string') {
+      relay = { enabled: r.enabled, transport: r.transport }
+    }
+  }
+
+  let cacheKeep: SidebarState['cacheKeep']
+  if (isRecord(raw.cacheKeep)) {
+    const ck = raw.cacheKeep
+    if (typeof ck.enabled === 'boolean') {
+      cacheKeep = {
+        enabled: ck.enabled,
+        window: typeof ck.window === 'string' ? ck.window : undefined,
+        trackedSessions:
+          typeof ck.trackedSessions === 'number'
+            ? ck.trackedSessions
+            : undefined,
+      }
+    }
+  }
+
+  return {
+    main,
+    fallbacks,
+    activeId: typeof raw.activeId === 'string' ? raw.activeId : undefined,
+    route:
+      typeof raw.route === 'string' ? raw.route : DEFAULT_SIDEBAR_STATE.route,
+    relay,
+    fastMode:
+      typeof raw.fastMode === 'boolean'
+        ? raw.fastMode
+        : DEFAULT_SIDEBAR_STATE.fastMode,
+    cacheKeep,
+    lastUpdated: typeof raw.lastUpdated === 'number' ? raw.lastUpdated : 0,
+  }
+}
+
+let writeChain: Promise<void> = Promise.resolve()
 
 export async function getSidebarState(): Promise<SidebarState> {
   try {
     const raw = await readFile(getSidebarStateFile(), 'utf8')
-    return JSON.parse(raw) as SidebarState
+    return normalizeSidebarState(JSON.parse(raw))
   } catch {
     return DEFAULT_SIDEBAR_STATE
   }
 }
 
-export async function setSidebarState(state: SidebarState): Promise<void> {
-  try {
-    const stateFile = getSidebarStateFile()
-    await mkdir(dirname(stateFile), { recursive: true })
-    await writeFile(stateFile, JSON.stringify(state), 'utf8')
-  } catch {
-    // Best-effort — sidebar is non-critical
-  }
+export async function setSidebarState(
+  state: SidebarState,
+  stateFile = getSidebarStateFile(),
+): Promise<void> {
+  writeChain = writeChain
+    .then(async () => {
+      await mkdir(dirname(stateFile), { recursive: true })
+      await writeFile(stateFile, JSON.stringify(state), 'utf8')
+    })
+    .catch(() => {
+      // Best-effort — sidebar is non-critical
+    })
+
+  return writeChain
+}
+
+export async function drainSidebarWrites(): Promise<void> {
+  return writeChain
 }
 
 // Resolve the currently-active account from activeId for the collapsed sidebar
@@ -92,7 +180,7 @@ export function resolveActiveAccount(state: SidebarState): {
     // accounts out of state.fallbacks, so in normal operation every entry is
     // enabled. Kept so this pure helper stays correct for any caller and is
     // exercised directly by the unit tests.
-    const fallback = state.fallbacks.find(
+    const fallback = state.fallbacks?.find(
       (account) => account.enabled && account.id === activeId,
     )
     if (fallback) {
@@ -103,7 +191,7 @@ export function resolveActiveAccount(state: SidebarState): {
       }
     }
   }
-  return { id: 'main', name: 'main', quota: state.main.quota }
+  return { id: 'main', name: 'main', quota: state.main?.quota ?? null }
 }
 
 export function getCollapsedQuotaSummary(quota: AccountQuota | null): {