@cortexkit/opencode-anthropic-auth 1.9.3 → 1.10.0

package/src/rpc/port-file.ts

@@ -0,0 +1,64 @@
+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,
+): 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
+  return live.sort((a, b) => b.startedAt - a.startedAt)[0] ?? null
+}

package/src/rpc/protocol.ts

@@ -0,0 +1,31 @@
+export type CommandModalName =
+  | 'claude-cache'
+  | 'claude-cachekeep'
+  | 'claude-quota'
+  | 'claude-dump'
+  | 'claude-fast'
+  | 'claude-routing'
+  | 'claude-killswitch'
+
+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
+}
+
+export interface ApplyResult {
+  text: string
+  knobs: Record<string, unknown>
+}

package/src/rpc/rpc-client.ts

@@ -0,0 +1,55 @@
+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>,
+): Promise<T | null> {
+  const entry = await discoverPortFile(dir)
+  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): RpcClient {
+  return {
+    async pending(lastReceivedId, sessionId) {
+      const out = await call<{ messages: RpcNotification[] }>(
+        dir,
+        'pending-notifications',
+        { lastReceivedId, sessionId },
+      )
+      return out?.messages ?? []
+    },
+    async apply(request) {
+      const out = await call<ApplyResult>(dir, 'apply', { ...request })
+      return out ?? { text: 'apply failed', knobs: {} }
+    },
+  }
+}

package/src/rpc/rpc-dir.ts

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto'
+import { homedir, tmpdir } from 'node:os'
+import { join } 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
+  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 }

package/src/rpc/rpc-server.ts

@@ -0,0 +1,121 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto'
+import { unlink } from 'node:fs/promises'
+import {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+} from 'node:http'
+import { join } from 'node:path'
+import type { drainNotifications } from './notifications'
+import { writePortFile } from './port-file'
+import type { ApplyRequest, ApplyResult } from './protocol'
+
+export interface RpcServerHandle {
+  port: number
+  token: string
+  stop: () => Promise<void>
+}
+
+export interface RpcServerOptions {
+  dir: string
+  drain: typeof drainNotifications
+  apply: (request: ApplyRequest) => Promise<ApplyResult>
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    let size = 0
+    req.on('data', (chunk: Buffer) => {
+      size += chunk.length
+      if (size > 1_000_000) {
+        req.destroy()
+        reject(new Error('body too large'))
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    req.on('error', reject)
+  })
+}
+
+function tokenOk(header: string | undefined, token: string): boolean {
+  if (!header?.startsWith('Bearer ')) return false
+  const got = Buffer.from(header.slice(7))
+  const want = Buffer.from(token)
+  return got.length === want.length && timingSafeEqual(got, want)
+}
+
+export async function startRpcServer(
+  options: RpcServerOptions,
+): Promise<RpcServerHandle> {
+  const token = randomBytes(32).toString('hex')
+  const server = createServer((req, res) => {
+    void dispatch(req, res)
+  })
+
+  async function dispatch(req: IncomingMessage, res: ServerResponse) {
+    const json = (status: number, value: unknown) => {
+      res.writeHead(status, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(value))
+    }
+    try {
+      const url = req.url ?? ''
+      if (req.method === 'GET' && url === '/health')
+        return json(200, { ok: true })
+      if (req.method !== 'POST' || !url.startsWith('/rpc/'))
+        return json(404, { error: 'not found' })
+      if (!tokenOk(req.headers.authorization, token))
+        return json(401, { error: 'unauthorized' })
+      const method = url.slice('/rpc/'.length)
+      const params = JSON.parse((await readBody(req)) || '{}') as Record<
+        string,
+        unknown
+      >
+      if (method === 'pending-notifications') {
+        const messages = options.drain(
+          Number(params.lastReceivedId ?? 0),
+          typeof params.sessionId === 'string' ? params.sessionId : undefined,
+        )
+        return json(200, { messages })
+      }
+      if (method === 'apply') {
+        const result = await options.apply(params as unknown as ApplyRequest)
+        return json(200, result)
+      }
+      return json(404, { error: 'unknown method' })
+    } catch (error) {
+      json(500, {
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  const port = await new Promise<number>((resolve, reject) => {
+    server.on('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const addr = server.address()
+      if (addr && typeof addr === 'object') resolve(addr.port)
+      else reject(new Error('no port'))
+    })
+  })
+  server.unref()
+  try {
+    await writePortFile(options.dir, { port, token, pid: process.pid })
+  } catch (error) {
+    await new Promise<void>((resolve) => server.close(() => resolve()))
+    throw error
+  }
+
+  return {
+    port,
+    token,
+    async stop() {
+      await new Promise<void>((resolve) => server.close(() => resolve()))
+      await unlink(join(options.dir, `port-${process.pid}.json`)).catch(
+        () => {},
+      )
+    },
+  }
+}

package/src/tui/command-dialogs.tsx

@@ -0,0 +1,229 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
+import type { OpenDialogPayload } from '../rpc/protocol.js'
+
+type ApplyFn = (
+  command: OpenDialogPayload['command'],
+  args: string,
+) => Promise<{ text: string }>
+
+function showText(api: TuiPluginApi, text: string) {
+  api.ui.dialog.setSize('xlarge')
+  api.ui.dialog.replace(() => (
+    <box flexDirection='column' padding={1} width='100%'>
+      <text>{text}</text>
+    </box>
+  ))
+}
+
+export function openCommandDialog(
+  api: TuiPluginApi,
+  payload: OpenDialogPayload,
+  apply: ApplyFn,
+) {
+  if (payload.command === 'claude-routing') {
+    const current = (payload.knobs.mode as string) ?? 'main-first'
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogSelect
+        title='Claude routing'
+        current={current}
+        options={[
+          {
+            title: 'Main first',
+            value: 'main-first',
+            description: 'Use the main account until exhausted',
+          },
+          {
+            title: 'Fallback first',
+            value: 'fallback-first',
+            description: 'Prefer fallback accounts, preserve main',
+          },
+        ]}
+        onSelect={(option) => {
+          void apply('claude-routing', String(option.value)).then((r) => {
+            api.ui.toast({ message: r.text })
+            api.ui.dialog.clear()
+          })
+        }}
+      />
+    ))
+    return
+  }
+
+  if (payload.command === 'claude-fast' || payload.command === 'claude-dump') {
+    const enabled = payload.knobs.enabled === true
+    const label =
+      payload.command === 'claude-fast' ? 'fast mode' : 'request dump'
+    const DialogConfirm = api.ui.DialogConfirm
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogConfirm
+        title={`Claude ${label}`}
+        message={`${payload.text}\n\n${enabled ? 'Disable' : 'Enable'} ${label}?`}
+        onConfirm={() => {
+          void apply(payload.command, enabled ? 'off' : 'on').then((r) => {
+            api.ui.toast({ message: r.text })
+            api.ui.dialog.clear()
+          })
+        }}
+        onCancel={() => api.ui.dialog.clear()}
+      />
+    ))
+    return
+  }
+
+  if (payload.command === 'claude-cache') {
+    const enabled = payload.knobs.enabled === true
+    const mode = (payload.knobs.mode as string) ?? 'hybrid'
+    const currentValue = enabled ? mode : 'off'
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogSelect
+        title='Claude 1h cache'
+        current={currentValue}
+        options={[
+          { title: 'Off', value: 'off', description: 'Disable 1h cache' },
+          {
+            title: 'Explicit',
+            value: 'explicit',
+            description: 'Existing OpenCode breakpoints',
+          },
+          {
+            title: 'Automatic',
+            value: 'automatic',
+            description: 'Top-level cache_control only',
+          },
+          {
+            title: 'Hybrid',
+            value: 'hybrid',
+            description: 'system + messages[0] + top-level',
+          },
+        ]}
+        onSelect={(option) => {
+          if (option.value === 'off') {
+            void apply('claude-cache', 'off').then((r) => {
+              api.ui.toast({ message: r.text })
+              api.ui.dialog.clear()
+            })
+            return
+          }
+          void apply('claude-cache', `mode ${option.value}`)
+            .then(() => apply('claude-cache', 'on'))
+            .then((r) => {
+              api.ui.toast({ message: r.text })
+              api.ui.dialog.clear()
+            })
+        }}
+      />
+    ))
+    return
+  }
+
+  if (payload.command === 'claude-cachekeep') {
+    const window = payload.knobs.window as
+      | { startHour: number; endHour: number }
+      | undefined
+    const seed = window
+      ? `${String(window.startHour).padStart(2, '0')}-${String(window.endHour).padStart(2, '0')}`
+      : ''
+    const DialogPrompt = api.ui.DialogPrompt
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogPrompt
+        title='Claude cachekeep window'
+        description={() => <text>{payload.text}</text>}
+        placeholder="HH-HH (e.g. 08-20) or 'off'"
+        value={seed}
+        onConfirm={(value: string) => {
+          void apply('claude-cachekeep', value.trim()).then((r) => {
+            api.ui.toast({ message: r.text })
+            api.ui.dialog.clear()
+          })
+        }}
+        onCancel={() => api.ui.dialog.clear()}
+      />
+    ))
+    return
+  }
+
+  if (payload.command === 'claude-killswitch') {
+    const config = (payload.knobs.config ?? {}) as {
+      enabled?: boolean
+      main?: Record<string, number>
+      accounts?: Record<string, Record<string, number>>
+    }
+    const accountIds = (payload.knobs.accountIds as string[]) ?? []
+    const enabled = config.enabled === true
+    const readT = (t: Record<string, number> | undefined) => {
+      const fh = t?.five_hour ?? t?.['5h'] ?? 5
+      const sd = t?.seven_day ?? t?.['1w'] ?? 10
+      return { fh, sd }
+    }
+    const mainT = readT(config.main)
+    const seedParts = [`main:${mainT.fh},${mainT.sd}`]
+    for (const id of accountIds) {
+      const t = readT(config.accounts?.[id] ?? config.main)
+      seedParts.push(`${id}:${t.fh},${t.sd}`)
+    }
+    const seed = seedParts.join(' ')
+
+    const openEdit = () => {
+      const DialogPrompt = api.ui.DialogPrompt
+      api.ui.dialog.setSize('xlarge')
+      api.ui.dialog.replace(() => (
+        <DialogPrompt
+          title='Killswitch thresholds'
+          description={() => <text>{payload.text}</text>}
+          placeholder='main:5,10 work-alt:5,10'
+          value={seed}
+          onConfirm={(value: string) => {
+            void apply('claude-killswitch', `set ${value.trim()}`).then((r) => {
+              api.ui.toast({ message: r.text })
+              api.ui.dialog.clear()
+            })
+          }}
+          onCancel={() => api.ui.dialog.clear()}
+        />
+      ))
+    }
+
+    const DialogSelect = api.ui.DialogSelect<string>
+    api.ui.dialog.setSize('xlarge')
+    api.ui.dialog.replace(() => (
+      <DialogSelect
+        title='Claude killswitch'
+        options={[
+          {
+            title: enabled ? 'Disable killswitch' : 'Enable killswitch',
+            value: enabled ? 'off' : 'on',
+            description: enabled
+              ? 'Stop hard-blocking on low quota'
+              : 'Hard-block requests when quota drops below thresholds',
+          },
+          {
+            title: 'Edit thresholds…',
+            value: 'edit',
+            description: 'Set per-account 5h,1w cutoffs',
+          },
+        ]}
+        onSelect={(option) => {
+          if (option.value === 'edit') {
+            openEdit()
+            return
+          }
+          void apply('claude-killswitch', String(option.value)).then((r) => {
+            api.ui.toast({ message: r.text })
+            api.ui.dialog.clear()
+          })
+        }}
+      />
+    ))
+    return
+  }
+
+  // fallback for quota (display-only)
+  showText(api, payload.text)
+}

package/src/tui.tsx

@@ -16,7 +16,8 @@ import {
   onCleanup,
   Show,
 } from 'solid-js'
-
+import { createRpcClient } from './rpc/rpc-client.js'
+import { getRpcDir } from './rpc/rpc-dir.js'
 import {
   type AccountQuota,
   computeQuotaPacing,
@@ -29,6 +30,7 @@ import {
   SEVEN_DAY_MS,
   type SidebarState,
 } from './sidebar-state.js'
+import { openCommandDialog } from './tui/command-dialogs.js'
 import {
   type AnthropicAuthTuiPrefs,
   type AppearancePrefs,
@@ -41,6 +43,9 @@ import {
   watchTuiPreferences,
 } from './tui-preferences.js'
 
+const RPC_POLL_MS = 500
+let rpcPollStarted = false
+
 const ID = 'cortexkit.anthropic-auth'
 
 // Plugin version for the header (mirrors the Magic Context / AFT convention).
@@ -345,6 +350,67 @@ function AccountBlock(props: {
   )
 }
 
+// --- Quota dialog content ---------------------------------------------------
+
+// Renders the same rich visualization as the sidebar (account blocks with
+// quota bars + pacing) so the modal matches the sidebar look.
+function QuotaDialogContent(props: {
+  api: TuiPluginApi
+  controller: SidebarController
+}) {
+  const prefs = props.controller.prefs
+  const [state, setState] = createSignal<SidebarState>(DEFAULT_SIDEBAR_STATE)
+  let lastUpdated = 0
+  async function refresh() {
+    const next = await readStateFromFile()
+    if (next.lastUpdated !== lastUpdated) {
+      lastUpdated = next.lastUpdated
+      setState(next)
+    }
+  }
+  createEffect(() => {
+    const timer = setInterval(refresh, prefs().pollMs)
+    onCleanup(() => clearInterval(timer))
+  })
+  setTimeout(refresh, 0)
+  const theme = () => props.api.theme.current
+  const enabledFallbacks = () => state().fallbacks.filter((f) => f.enabled)
+  return (
+    <box flexDirection='column' padding={2} width='100%' alignItems='center'>
+      <box flexDirection='column' width={58}>
+        <box width='100%' justifyContent='center' marginBottom={1}>
+          <text fg={theme().text}>
+            <b>Quota</b>
+          </text>
+        </box>
+        <AccountBlock
+          theme={theme()}
+          appearance={prefs().appearance}
+          name='main'
+          quota={state().main.quota}
+          active={state().activeId === 'main'}
+          pacingEnabled={prefs().sections.pacing}
+        />
+        <Show when={prefs().sections.fallbackAccounts}>
+          <For each={enabledFallbacks()}>
+            {(fb) => (
+              <AccountBlock
+                theme={theme()}
+                appearance={prefs().appearance}
+                name={fb.label ?? fb.id}
+                quota={fb.quota}
+                active={state().activeId === fb.id}
+                pacingEnabled={prefs().sections.pacing}
+                marginTop={1}
+              />
+            )}
+          </For>
+        </Show>
+      </box>
+    </box>
+  )
+}
+
 // --- State plumbing ---------------------------------------------------------
 
 async function readStateFromFile(): Promise<SidebarState> {
@@ -701,6 +767,44 @@ const tui: TuiPlugin = async (api) => {
       },
     },
   })
+
+  if (!rpcPollStarted) {
+    rpcPollStarted = true
+    const rpcClient = createRpcClient(getRpcDir(api.state.path.directory ?? ''))
+    let lastNotificationId = 0
+    let rpcInFlight = false
+    setInterval(() => {
+      if (rpcInFlight) return
+      const current = (api.route as { current?: unknown }).current
+      const resolved =
+        typeof current === 'function' ? (current as () => unknown)() : current
+      const sessionId = (
+        resolved as { params?: { sessionID?: string } } | undefined
+      )?.params?.sessionID
+      rpcInFlight = true
+      void rpcClient
+        .pending(lastNotificationId, sessionId)
+        .then((messages) => {
+          for (const message of [...messages].sort((a, b) => a.id - b.id)) {
+            lastNotificationId = Math.max(lastNotificationId, message.id)
+            if (message.payload.command === 'claude-quota') {
+              api.ui.dialog.setSize('xlarge')
+              api.ui.dialog.replace(() => (
+                <QuotaDialogContent api={api} controller={controller} />
+              ))
+              continue
+            }
+            openCommandDialog(api, message.payload, (command, args) =>
+              rpcClient.apply({ command, arguments: args }),
+            )
+          }
+        })
+        .catch(() => {})
+        .finally(() => {
+          rpcInFlight = false
+        })
+    }, RPC_POLL_MS)
+  }
 }
 
 const plugin: TuiPluginModule & { id: string } = {