@cortexkit/opencode-openai-auth 0.1.2 → 0.1.4

package/src/rpc/rpc-dir.ts

@@ -0,0 +1,22 @@
+import { createHash } from 'node:crypto'
+import { homedir, tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+const RPC_DIR_ENV = 'OPENCODE_OPENAI_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()
+  // A relative override is anchored to projectDirectory (shared by both processes)
+  // so server and TUI halves always resolve the same dir. An absolute override is
+  // used as-is (resolve(base, absolute) returns the absolute path unchanged).
+  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', 'openai-auth', 'rpc', hash)
+}
+
+export { tmpdir }

package/src/rpc/rpc-server.ts

@@ -0,0 +1,129 @@
+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 { createLogger } from '../logger'
+import type { drainNotifications } from './notifications'
+import { writePortFile } from './port-file'
+import type { ApplyRequest, ApplyResult } from './protocol'
+
+const log = createLogger('rpc')
+
+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) => {
+      // Guard against writing to a socket that was destroyed (e.g. when
+      // readBody rejected after req.destroy() on an oversized body).
+      if (res.headersSent || res.writableEnded || res.destroyed) return
+      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 body = await readBody(req)
+      const params = JSON.parse(body || '{}') 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 })
+    log.debug('rpc server pid', {
+      pid: process.pid,
+      rpcPort: port,
+    })
+  } 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/sidebar-state.ts

@@ -0,0 +1,312 @@
+export interface QuotaWindow {
+  usedPercent: number
+  remainingPercent: number
+  resetsAt?: string
+}
+
+export interface AccountQuota {
+  primary?: QuotaWindow
+  secondary?: QuotaWindow
+}
+
+export interface SidebarAccountState {
+  id: string
+  label: string | undefined
+  quota: AccountQuota | null
+  killed: boolean
+  enabled: boolean
+}
+
+export interface SidebarState {
+  main: {
+    quota: AccountQuota | null
+    killed: boolean
+    quotaBackedOff?: boolean
+    quotaBackoffUntil?: number
+    refreshBackedOff?: boolean
+    refreshBackoffUntil?: number
+  }
+  fallbacks: SidebarAccountState[]
+  activeId: string | undefined
+  route: string
+  planType?: string
+  credits?: number
+  lastUpdated: number
+}
+
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { createLogger } from './logger'
+
+const logSb = createLogger('sidebar')
+
+const STATE_FILE_ENV = 'OPENCODE_OPENAI_AUTH_SIDEBAR_STATE_FILE'
+const DEFAULT_STATE_DIR = join(tmpdir(), 'opencode-openai-auth')
+const DEFAULT_STATE_FILE = join(DEFAULT_STATE_DIR, 'sidebar-state.json')
+
+export function getSidebarStateFile(): string {
+  return process.env[STATE_FILE_ENV] || DEFAULT_STATE_FILE
+}
+
+export const DEFAULT_SIDEBAR_STATE: SidebarState = {
+  main: { quota: null, killed: false },
+  fallbacks: [],
+  activeId: undefined,
+  route: 'main',
+  lastUpdated: 0,
+}
+
+/**
+ * Normalize an arbitrary parsed value into a well-formed SidebarState.
+ *
+ * JSON.parse + `as SidebarState` is an unchecked cast — a partial, old, or
+ * malformed state file passes through and the TUI's `state().main.quota` /
+ * `state().fallbacks.filter(...)` throw at runtime. This helper guarantees
+ * every required field is present and correctly typed before the value leaves
+ * the I/O boundary, so a bad file can never crash the host TUI.
+ */
+export function normalizeSidebarState(raw: unknown): SidebarState {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return DEFAULT_SIDEBAR_STATE
+  }
+
+  const r = raw as Record<string, unknown>
+
+  // main — must be an object with at least quota and killed
+  const rawMain = r.main
+  let main: SidebarState['main']
+  if (
+    rawMain !== null &&
+    typeof rawMain === 'object' &&
+    !Array.isArray(rawMain)
+  ) {
+    const m = rawMain as Record<string, unknown>
+    main = {
+      quota: ('quota' in m ? m.quota : null) as AccountQuota | null,
+      killed: typeof m.killed === 'boolean' ? m.killed : false,
+      // Preserve optional backoff fields if present
+      ...(typeof m.quotaBackedOff === 'boolean'
+        ? { quotaBackedOff: m.quotaBackedOff }
+        : {}),
+      ...(typeof m.quotaBackoffUntil === 'number'
+        ? { quotaBackoffUntil: m.quotaBackoffUntil }
+        : {}),
+      ...(typeof m.refreshBackedOff === 'boolean'
+        ? { refreshBackedOff: m.refreshBackedOff }
+        : {}),
+      ...(typeof m.refreshBackoffUntil === 'number'
+        ? { refreshBackoffUntil: m.refreshBackoffUntil }
+        : {}),
+    }
+  } else {
+    main = { quota: null, killed: false }
+  }
+
+  // fallbacks — must be an array; keep entries that are objects with a string
+  // id, and normalize each entry's inner fields so the TUI never reads a
+  // wrong-typed value (e.g. a string `enabled`) off a malformed file.
+  const rawFallbacks = r.fallbacks
+  const fallbacks: SidebarAccountState[] = Array.isArray(rawFallbacks)
+    ? rawFallbacks
+        .filter(
+          (entry): entry is Record<string, unknown> =>
+            entry !== null &&
+            typeof entry === 'object' &&
+            !Array.isArray(entry) &&
+            typeof (entry as Record<string, unknown>).id === 'string',
+        )
+        .map((e) => ({
+          id: e.id as string,
+          label: typeof e.label === 'string' ? e.label : undefined,
+          quota: ('quota' in e ? e.quota : null) as AccountQuota | null,
+          killed: typeof e.killed === 'boolean' ? e.killed : false,
+          enabled: typeof e.enabled === 'boolean' ? e.enabled : true,
+        }))
+    : []
+
+  // activeId — string or undefined
+  const activeId = typeof r.activeId === 'string' ? r.activeId : undefined
+
+  // route — string, default 'main'
+  const route =
+    typeof r.route === 'string' ? r.route : DEFAULT_SIDEBAR_STATE.route
+
+  // lastUpdated — number, default 0
+  const lastUpdated = typeof r.lastUpdated === 'number' ? r.lastUpdated : 0
+
+  // Optional top-level fields
+  const planType = typeof r.planType === 'string' ? r.planType : undefined
+  const credits = typeof r.credits === 'number' ? r.credits : undefined
+
+  return {
+    main,
+    fallbacks,
+    activeId,
+    route,
+    lastUpdated,
+    ...(planType !== undefined ? { planType } : {}),
+    ...(credits !== undefined ? { credits } : {}),
+  }
+}
+
+export async function getSidebarState(): Promise<SidebarState> {
+  try {
+    const raw = await readFile(getSidebarStateFile(), 'utf8')
+    return normalizeSidebarState(JSON.parse(raw))
+  } catch {
+    return DEFAULT_SIDEBAR_STATE
+  }
+}
+
+// Serialization chain: concurrent calls are queued so a stale background
+// write cannot land after a newer one and corrupt the file.
+let sidebarWriteChain: Promise<void> = Promise.resolve()
+
+/**
+ * Write sidebar state to disk, serialized through a promise chain so
+ * concurrent callers never interleave or let a stale write land last.
+ *
+ * @param state  The state to persist.
+ * @param file   Explicit path override — callers that bind the path at init
+ *               time (e.g. the index.ts loader) pass this so late callbacks
+ *               always write to the path that was current when the loader ran,
+ *               even if the env changes underneath them during tests.
+ *               Defaults to getSidebarStateFile() (per-call resolution).
+ */
+export function setSidebarState(
+  state: SidebarState,
+  file = getSidebarStateFile(),
+): Promise<void> {
+  sidebarWriteChain = sidebarWriteChain
+    .then(() => doWriteSidebarState(state, file))
+    .catch(() => {})
+  return sidebarWriteChain
+}
+
+async function doWriteSidebarState(
+  state: SidebarState,
+  file: string,
+): Promise<void> {
+  try {
+    await mkdir(dirname(file), { recursive: true })
+    await writeFile(file, JSON.stringify(state), 'utf8')
+  } catch (e) {
+    logSb.warn('sidebar write failed', {
+      pid: process.pid,
+      error: e instanceof Error ? e.message : String(e),
+    })
+  }
+}
+
+/**
+ * Await all pending sidebar writes. Tests call this before restoring env
+ * vars in teardown so no in-flight write can re-resolve getSidebarStateFile()
+ * after the env is changed.
+ */
+export function drainSidebarWrites(): Promise<void> {
+  return sidebarWriteChain
+}
+
+// Resolve the currently-active account from activeId for the collapsed sidebar
+// view. activeId === 'main' (or undefined/unmatched/disabled) → the main
+// account; otherwise the enabled fallback whose id matches.
+export function resolveActiveAccount(state: SidebarState): {
+  id: string
+  name: string
+  quota: AccountQuota | null
+  killed: boolean
+} {
+  const activeId = state.activeId
+  if (activeId && activeId !== 'main') {
+    const fallback = state.fallbacks.find(
+      (account) => account.enabled && account.id === activeId,
+    )
+    if (fallback) {
+      return {
+        id: fallback.id,
+        name: fallback.label ?? fallback.id,
+        quota: fallback.quota,
+        killed: fallback.killed,
+      }
+    }
+  }
+  return {
+    id: 'main',
+    name: 'main',
+    quota: state.main.quota,
+    killed: state.main.killed,
+  }
+}
+
+export function getCollapsedQuotaSummary(quota: AccountQuota | null): {
+  primaryUsedPercent: number | null
+  secondaryUsedPercent: number | null
+  text: string | null
+} {
+  const primaryUsedPercent = quota?.primary?.usedPercent ?? null
+  const secondaryUsedPercent = quota?.secondary?.usedPercent ?? null
+  if (primaryUsedPercent == null && secondaryUsedPercent == null) {
+    return { primaryUsedPercent, secondaryUsedPercent, text: null }
+  }
+
+  return {
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    text: `5h: ${primaryUsedPercent == null ? '\u2014' : `${Math.round(primaryUsedPercent)}%`} 7d: ${secondaryUsedPercent == null ? '\u2014' : `${Math.round(secondaryUsedPercent)}%`}`,
+  }
+}
+
+export const FIVE_HOUR_MS = 5 * 60 * 60 * 1000
+export const SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1000
+
+const PACING_MIN_ELAPSED_MS = 5 * 60 * 1000
+const PACING_MIN_ELAPSED_FRACTION = 0.01
+const ON_PACE_DELTA = 1
+
+export interface QuotaPacing {
+  pacePercent: number
+  deltaPercent: number
+  state: 'deficit' | 'reserve' | 'on-pace'
+  runsOutAt: string | null
+}
+
+// Even-burn pacing for a quota window. The window start is inferred from the
+// reset timestamp minus the window length. Two metrics: deltaPercent compares
+// usage against a uniform burn-down (positive = deficit), and runsOutAt
+// projects the current average burn rate forward — null means the window
+// lasts until reset at that rate. Returns null when there is no reset
+// timestamp or the elapsed time is too small to give a meaningful rate.
+export function computeQuotaPacing(
+  window: QuotaWindow,
+  windowMs: number,
+  now: number,
+): QuotaPacing | null {
+  if (!window.resetsAt) return null
+  const resetsAt = new Date(window.resetsAt).getTime()
+  if (!Number.isFinite(resetsAt)) return null
+  const start = resetsAt - windowMs
+  const elapsed = now - start
+  if (elapsed < PACING_MIN_ELAPSED_MS) return null
+  if (elapsed < windowMs * PACING_MIN_ELAPSED_FRACTION) return null
+  if (elapsed >= windowMs) return null
+
+  const used = window.usedPercent
+  const pacePercent = Math.min(Math.max((elapsed / windowMs) * 100, 0), 100)
+  const deltaPercent = used - pacePercent
+  const state =
+    Math.abs(deltaPercent) < ON_PACE_DELTA
+      ? 'on-pace'
+      : deltaPercent > 0
+        ? 'deficit'
+        : 'reserve'
+
+  let runsOutAt: string | null = null
+  if (used > 0) {
+    const msToFull = (elapsed * 100) / used
+    const runOut = start + msToFull
+    if (runOut < resetsAt) runsOutAt = new Date(runOut).toISOString()
+  }
+
+  return { pacePercent, deltaPercent, state, runsOutAt }
+}