@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/src/tui-compiled/raw/tui-preferences.ts

@@ -1,328 +0,0 @@
-import { watch } from 'node:fs'
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { basename, dirname, join } from 'node:path'
-import { applyEdits, modify, type ParseError, parse } from 'jsonc-parser'
-
-export const TUI_PREFS_FILE_ENV = 'OPENCODE_TUI_PREFERENCES_FILE'
-const FILE_NAME = 'tui-preferences.jsonc'
-
-// Shared preferences file for opencode TUI plugins. One top-level key per
-// plugin (short name, e.g. "openai-auth"). The file is optional: every
-// reader must fall back to defaults when it is missing or malformed.
-export function getTuiPreferencesFile(): string {
-  const override = process.env[TUI_PREFS_FILE_ENV]
-  if (override) return override
-  const configDir =
-    process.env.OPENCODE_CONFIG_DIR ||
-    join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'opencode')
-  return join(configDir, FILE_NAME)
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-// Tolerant read: missing file, parse errors, or a non-object root all resolve
-// to {} so the sidebar never crashes on user-edited content. jsonc-parser's
-// fault-tolerant parse can still hand back a partial object for an
-// unterminated/bracketed file or trailing garbage, so we collect errors and
-// treat any reported fault as malformed.
-export async function readTuiPreferencesFile(): Promise<
-  Record<string, unknown>
-> {
-  try {
-    const raw = await readFile(getTuiPreferencesFile(), 'utf8')
-    const errors: ParseError[] = []
-    const root: unknown = parse(raw, errors, { allowTrailingComma: true })
-    if (errors.length > 0) return {}
-    return isRecord(root) ? root : {}
-  } catch {
-    return {}
-  }
-}
-
-export const PLUGIN_KEY = 'openai-auth'
-export const DEFAULT_SLOT_ORDER = 160
-
-export interface OpenaiAuthTuiPrefs {
-  forceToTop: boolean
-  order: number
-  startCollapsed: boolean
-  rememberCollapsed: boolean
-  // null = never persisted; seed the UI from startCollapsed instead.
-  collapsed: boolean | null
-  pollMs: number
-  refreshDebounceMs: number
-  header: {
-    label: string
-    showVersion: boolean
-  }
-  sections: {
-    quota: boolean
-    fallbackAccounts: boolean
-    routing: boolean
-    health: boolean
-    pacing: boolean
-  }
-  appearance: {
-    barWidth: number
-    barFilledChar: string
-    barEmptyChar: string
-    warnThreshold: number
-    errorThreshold: number
-  }
-}
-
-export type AppearancePrefs = OpenaiAuthTuiPrefs['appearance']
-
-export const DEFAULT_PREFS: OpenaiAuthTuiPrefs = {
-  forceToTop: false,
-  order: DEFAULT_SLOT_ORDER,
-  startCollapsed: false,
-  rememberCollapsed: true,
-  collapsed: null,
-  pollMs: 1500,
-  refreshDebounceMs: 200,
-  header: { label: 'OPENAI', showVersion: true },
-  sections: {
-    quota: true,
-    fallbackAccounts: true,
-    routing: true,
-    health: true,
-    pacing: true,
-  },
-  appearance: {
-    barWidth: 10,
-    barFilledChar: '\u2588',
-    barEmptyChar: '\u2591',
-    warnThreshold: 50,
-    errorThreshold: 80,
-  },
-}
-
-function bool(value: unknown, fallback: boolean): boolean {
-  return typeof value === 'boolean' ? value : fallback
-}
-
-function int(
-  value: unknown,
-  fallback: number,
-  min: number,
-  max: number,
-): number {
-  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback
-  return Math.min(Math.max(Math.round(value), min), max)
-}
-
-function label(value: unknown, fallback: string, maxLength: number): string {
-  if (typeof value !== 'string' || value.length === 0) return fallback
-  return value.slice(0, maxLength)
-}
-
-function char(value: unknown, fallback: string): string {
-  if (typeof value !== 'string') return fallback
-  const first = [...value][0]
-  return first ?? fallback
-}
-
-// Per-key validation: every value is independently clamped/defaulted so one
-// bad entry never poisons the rest. Never throws.
-export function resolveOpenaiAuthPrefs(
-  root: Record<string, unknown>,
-): OpenaiAuthTuiPrefs {
-  const entry = root[PLUGIN_KEY]
-  if (!isRecord(entry)) return structuredClone(DEFAULT_PREFS)
-
-  const d = DEFAULT_PREFS
-  const header = isRecord(entry.header) ? entry.header : {}
-  const sections = isRecord(entry.sections) ? entry.sections : {}
-  const appearance = isRecord(entry.appearance) ? entry.appearance : {}
-
-  const warnThreshold = int(
-    appearance.warnThreshold,
-    d.appearance.warnThreshold,
-    0,
-    99,
-  )
-  const errorThreshold = Math.max(
-    int(appearance.errorThreshold, d.appearance.errorThreshold, 0, 100),
-    Math.min(warnThreshold + 1, 100),
-  )
-
-  return {
-    forceToTop: bool(entry.forceToTop, d.forceToTop),
-    order: int(entry.order, d.order, -10000, 10000),
-    startCollapsed: bool(entry.startCollapsed, d.startCollapsed),
-    rememberCollapsed: bool(entry.rememberCollapsed, d.rememberCollapsed),
-    collapsed: typeof entry.collapsed === 'boolean' ? entry.collapsed : null,
-    pollMs: int(entry.pollMs, d.pollMs, 500, 30000),
-    refreshDebounceMs: int(
-      entry.refreshDebounceMs,
-      d.refreshDebounceMs,
-      50,
-      5000,
-    ),
-    header: {
-      label: label(header.label, d.header.label, 20),
-      showVersion: bool(header.showVersion, d.header.showVersion),
-    },
-    sections: {
-      quota: bool(sections.quota, d.sections.quota),
-      fallbackAccounts: bool(
-        sections.fallbackAccounts,
-        d.sections.fallbackAccounts,
-      ),
-      routing: bool(sections.routing, d.sections.routing),
-      health: bool(sections.health, d.sections.health),
-      pacing: bool(sections.pacing, d.sections.pacing),
-    },
-    appearance: {
-      barWidth: int(appearance.barWidth, d.appearance.barWidth, 4, 40),
-      barFilledChar: char(appearance.barFilledChar, d.appearance.barFilledChar),
-      barEmptyChar: char(appearance.barEmptyChar, d.appearance.barEmptyChar),
-      warnThreshold,
-      errorThreshold,
-    },
-  }
-}
-
-const FORCE_TOP_BASE = -100000
-
-// Shared forceToTop convention: forced plugins sort below FORCE_TOP_BASE,
-// ordered among themselves by their top-level key's position in the file, so
-// users reprioritize by reordering keys. The user-facing `order` knob clamps
-// to -10000..10000, strictly above the forced band, so a manual order can
-// never beat forceToTop. Host slots render ascending by order; opencode's
-// built-ins occupy 100-500.
-//
-// Key-naming requirement: plugin keys must be non-integer-like short names
-// (e.g. "openai-auth"). JavaScript object key iteration order hoists
-// integer-like keys ("0", "1", "42") ahead of any string keys, which would
-// skew the indexOf-based ordering of forced plugins. The shared
-// `tui-preferences.jsonc` convention requires non-numeric names, so this
-// implementation does not paper over the JS quirk.
-export function computeEffectiveOrder(
-  root: Record<string, unknown>,
-  pluginKey: string,
-  defaultOrder: number,
-): number {
-  const entry = root[pluginKey]
-  if (!isRecord(entry)) return defaultOrder
-  if (entry.forceToTop === true) {
-    return FORCE_TOP_BASE + Object.keys(root).indexOf(pluginKey)
-  }
-  return int(entry.order, defaultOrder, -10000, 10000)
-}
-
-const TEMPLATE = `// Shared preferences for opencode TUI plugins.
-// One top-level key per plugin (short name). See each plugin's README for
-// its supported settings. This file is safe to hand-edit; plugins update
-// individual keys in place and preserve comments.
-{}
-`
-
-type JsonValue = string | number | boolean | null
-
-async function writePreference(
-  pluginKey: string,
-  path: string[],
-  value: JsonValue,
-): Promise<void> {
-  const file = getTuiPreferencesFile()
-  await mkdir(dirname(file), { recursive: true })
-  let text: string
-  try {
-    text = await readFile(file, 'utf8')
-  } catch {
-    text = ''
-  }
-  if (text.trim() === '') text = TEMPLATE
-  const edits = modify(text, [pluginKey, ...path], value, {
-    formattingOptions: { insertSpaces: true, tabSize: 2 },
-  })
-  const next = applyEdits(text, edits)
-  const tmp = `${file}.${process.pid}.tmp`
-  await writeFile(tmp, next, 'utf8')
-  await rename(tmp, file)
-}
-
-let writeChain: Promise<void> = Promise.resolve()
-
-// Writes are serialized on a promise chain: each update re-reads the file,
-// applies a minimal comment-preserving edit to one property, and replaces the
-// file atomically (temp + rename in the same directory). Best-effort by
-// design — preferences are never worth crashing the TUI over.
-export function queueTuiPreferenceUpdate(
-  pluginKey: string,
-  path: string[],
-  value: JsonValue,
-): Promise<void> {
-  writeChain = writeChain
-    .then(() => writePreference(pluginKey, path, value))
-    .catch(() => {})
-  return writeChain
-}
-
-const WATCH_DEBOUNCE_MS = 150
-
-// Watches the directory rather than the file: editors and our own atomic
-// writes replace the file via rename, which kills file-level watchers.
-//
-// Filtering is two-stage:
-//   1. Filename pre-filter: only debounce events for the preferences file
-//      name, or our atomic-write temp file. This is a cheap first pass that
-//      drops the common case (unrelated sibling files).
-//   2. Content check inside the debounce: after the timer fires, re-read
-//      the file and compare it against the last seen content. Only fire
-//      `onChange` when the content actually changed. This is the authority.
-//      Some platforms (notably macOS FSEvents and a few inotify backends)
-//      can misattribute a rename of an unrelated sibling file to the
-//      real preferences filename in addition to emitting the sibling's
-//      own event, so a name-only filter still produces a stray callback.
-//      A content comparison is robust against that, against coalesced
-//      events, and against mtime granularity.
-//
-// Returns a disposer; never throws.
-export function watchTuiPreferences(onChange: () => void): () => void {
-  const file = getTuiPreferencesFile()
-  const name = basename(file)
-  let timer: ReturnType<typeof setTimeout> | null = null
-  let lastSeen: string | null = null
-  // Seed asynchronously; a real change that fires before the seed resolves
-  // still wins because the debounce re-reads the file fresh and compares
-  // against `lastSeen` (which will be `null` → does not match → fires).
-  void readFile(file, 'utf8')
-    .then((text) => {
-      if (lastSeen === null) lastSeen = text
-    })
-    .catch(() => {})
-  try {
-    const watcher = watch(dirname(file), (_event, filename) => {
-      // Exact match against the preferences file name, plus the temp file
-      // we use for atomic writes (carrying our pid + `.tmp`).
-      const isOurs =
-        filename === name ||
-        (filename?.startsWith(`${name}.`) && filename.endsWith('.tmp'))
-      if (filename != null && !isOurs) return
-      if (timer) clearTimeout(timer)
-      timer = setTimeout(() => {
-        timer = null
-        void readFile(file, 'utf8')
-          .catch(() => null)
-          .then((text) => {
-            if (text === null) return
-            if (text === lastSeen) return
-            lastSeen = text
-            onChange()
-          })
-      }, WATCH_DEBOUNCE_MS)
-    })
-    return () => {
-      if (timer) clearTimeout(timer)
-      watcher.close()
-    }
-  } catch {
-    return () => {}
-  }
-}

package/src/tui-compiled/runtime/core-account-paths.ts

@@ -1,114 +0,0 @@
-import { realpathSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { basename, dirname, join, resolve } from 'node:path'
-import {
-  ACCOUNT_FILE_NAME,
-  ACCOUNT_STATE_FILE_NAME,
-  type AccountPaths,
-  deriveStatePath,
-} from '../shared/internal.ts'
-
-/**
- * Where OpenCode's account store lives.
- *
- * This is the ONLY definition of this host's resolution rules. The store code
- * itself takes both paths as arguments and resolves nothing, so the lock and
- * the write it guards can never disagree about which file they mean — a
- * disagreement would lose mutual exclusion on a file holding credentials while
- * every test still passed, since each side works on its own.
- *
- * The file names come from the core so the two hosts cannot drift apart on what
- * the store is called.
- */
-
-export type { AccountPaths }
-export { ACCOUNT_FILE_NAME, ACCOUNT_STATE_FILE_NAME, deriveStatePath }
-
-function getConfigDir() {
-  if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
-    return process.env.OPENCODE_CONFIG_DIR.trim()
-  }
-  return join(
-    process.env.XDG_CONFIG_HOME || join(homedir(), '.config'),
-    'opencode',
-  )
-}
-
-export function getAccountStoragePath() {
-  return (
-    process.env.OPENCODE_OPENAI_AUTH_FILE?.trim() ||
-    join(getConfigDir(), ACCOUNT_FILE_NAME)
-  )
-}
-
-function normalizePathForComparison(path: string, platform: NodeJS.Platform) {
-  const resolved = resolve(path)
-  return platform === 'win32' || platform === 'darwin'
-    ? resolved.toLowerCase()
-    : resolved
-}
-
-function realpathForComparison(path: string): string | undefined {
-  try {
-    return realpathSync.native(path)
-  } catch {
-    try {
-      return join(realpathSync.native(dirname(path)), basename(path))
-    } catch {
-      return undefined
-    }
-  }
-}
-
-/**
- * Detect path aliases without requiring either file to exist. This is defense
- * in depth: hardlinks and bind mounts can still make distinct paths share a
- * file, because neither is distinguishable through pathname identity.
- */
-export function accountPathsCollide(
-  configPath: string,
-  statePath: string,
-  platform: NodeJS.Platform = process.platform,
-) {
-  if (
-    normalizePathForComparison(configPath, platform) ===
-    normalizePathForComparison(statePath, platform)
-  ) {
-    return true
-  }
-
-  const configIdentity = realpathForComparison(configPath)
-  const stateIdentity = realpathForComparison(statePath)
-  return (
-    configIdentity !== undefined &&
-    stateIdentity !== undefined &&
-    normalizePathForComparison(configIdentity, platform) ===
-      normalizePathForComparison(stateIdentity, platform)
-  )
-}
-
-export function getAccountStatePath(configPath = getAccountStoragePath()) {
-  const explicit = process.env.OPENCODE_OPENAI_AUTH_STATE_FILE?.trim()
-  if (explicit) {
-    if (accountPathsCollide(configPath, explicit)) {
-      throw new Error(
-        `OPENCODE_OPENAI_AUTH_STATE_FILE resolves to the config path (${resolve(configPath)}). Set OPENCODE_OPENAI_AUTH_STATE_FILE to a different file.`,
-      )
-    }
-    return explicit
-  }
-  return deriveStatePath(configPath)
-}
-
-/**
- * Both file paths a store call needs, resolved the way this host resolves them.
- *
- * Every call site that used to pass a single config path and let the store
- * derive the state path now passes this pair instead, so the state-file
- * override keeps being honoured in exactly the places it was before.
- */
-export function getAccountPaths(
-  configPath = getAccountStoragePath(),
-): AccountPaths {
-  return { configPath, statePath: getAccountStatePath(configPath) }
-}

package/src/tui-compiled/runtime/core-custody-state.ts

@@ -1,243 +0,0 @@
-export type CustodyMode = 'local' | 'claustrum'
-
-export type ManifestCustodyState = 'absent' | 'present' | 'unreadable'
-
-export type LocalCustodyState =
-  | 'real'
-  | 'tombstone'
-  | 'empty'
-  | 'gone'
-  | 'slot-absent'
-
-export type VaultCustodyState =
-  | 'serves'
-  | 'cold'
-  | 'needs_reauth'
-  | 'identity_mismatch'
-  | 'no_handle'
-
-export const CUSTODY_INERT_REASONS = [
-  'needs-login',
-  'mode-mismatch',
-  'corrupt-under-binding',
-  'manifest-unreadable',
-  'unbound-under-claustrum',
-  'orphan-tombstone',
-  'vault-cold',
-  'vault-reauth',
-  'identity-mismatch',
-  'no-handle',
-  'takeover-incomplete',
-  'new-local-family-under-claustrum',
-  'takeover-incomplete/vault-unavailable',
-  'takeover-incomplete/slot-absent',
-] as const
-
-export type CustodyInertReason = (typeof CUSTODY_INERT_REASONS)[number]
-
-export type CustodyVerdict =
-  | { kind: 'LOCAL' }
-  | {
-      kind: 'VAULT'
-      canonicalize?: boolean
-      installTombstone?: boolean
-    }
-  | {
-      kind: 'INERT'
-      reason: CustodyInertReason
-      installTombstone?: boolean
-      canonicalize?: boolean
-    }
-  | { kind: 'NEEDS_LOGIN'; reason?: 'corrupt' }
-
-export interface EvaluateCustodyStartupInput {
-  mode: CustodyMode
-  manifest: ManifestCustodyState
-  local: LocalCustodyState
-  vault: () => VaultCustodyState
-  manifestFailureReason?: string
-  fingerprintMatch?: boolean
-  verifiedInProcessLogin: boolean
-  isMain?: boolean
-}
-
-function unreachable(value: never): never {
-  return value
-}
-
-function withCanonicalization<
-  T extends Extract<CustodyVerdict, { kind: 'VAULT' | 'INERT' }>,
->(local: LocalCustodyState, verdict: T): T | (T & { canonicalize: true }) {
-  return local === 'empty' ? { ...verdict, canonicalize: true } : verdict
-}
-
-function evaluateLocal(local: LocalCustodyState): CustodyVerdict {
-  switch (local) {
-    case 'real':
-      return { kind: 'LOCAL' }
-    case 'tombstone':
-    case 'empty':
-    case 'slot-absent':
-      return { kind: 'NEEDS_LOGIN' }
-    case 'gone':
-      return { kind: 'NEEDS_LOGIN', reason: 'corrupt' }
-  }
-  return unreachable(local)
-}
-
-function evaluateLocalWithBinding(
-  local: LocalCustodyState,
-  verifiedInProcessLogin: boolean,
-): CustodyVerdict {
-  switch (local) {
-    case 'real':
-      return verifiedInProcessLogin
-        ? { kind: 'LOCAL' }
-        : { kind: 'INERT', reason: 'needs-login' }
-    case 'tombstone':
-    case 'empty':
-    case 'slot-absent':
-      return { kind: 'INERT', reason: 'mode-mismatch' }
-    case 'gone':
-      return { kind: 'INERT', reason: 'corrupt-under-binding' }
-  }
-  return unreachable(local)
-}
-
-function evaluateUnboundClaustrum(local: LocalCustodyState): CustodyVerdict {
-  switch (local) {
-    case 'tombstone':
-    case 'empty':
-      return { kind: 'INERT', reason: 'orphan-tombstone' }
-    case 'real':
-    case 'gone':
-    case 'slot-absent':
-      return { kind: 'INERT', reason: 'unbound-under-claustrum' }
-  }
-  return unreachable(local)
-}
-
-function evaluateTombstone(
-  local: Extract<LocalCustodyState, 'tombstone' | 'empty'>,
-  vault: VaultCustodyState,
-): CustodyVerdict {
-  switch (vault) {
-    case 'serves':
-      return withCanonicalization(local, { kind: 'VAULT' })
-    case 'cold':
-      return withCanonicalization(local, {
-        kind: 'INERT',
-        reason: 'vault-cold',
-      })
-    case 'needs_reauth':
-      return withCanonicalization(local, {
-        kind: 'INERT',
-        reason: 'vault-reauth',
-      })
-    case 'identity_mismatch':
-      return withCanonicalization(local, {
-        kind: 'INERT',
-        reason: 'identity-mismatch',
-      })
-    case 'no_handle':
-      return withCanonicalization(local, { kind: 'INERT', reason: 'no-handle' })
-  }
-  return unreachable(vault)
-}
-
-function evaluateReal(
-  vault: VaultCustodyState,
-  fingerprintMatch: boolean | undefined,
-): CustodyVerdict {
-  switch (vault) {
-    case 'serves':
-      return fingerprintMatch === false
-        ? { kind: 'INERT', reason: 'new-local-family-under-claustrum' }
-        : { kind: 'INERT', reason: 'takeover-incomplete' }
-    case 'cold':
-    case 'needs_reauth':
-      return { kind: 'INERT', reason: 'takeover-incomplete/vault-unavailable' }
-    case 'identity_mismatch':
-      return { kind: 'INERT', reason: 'identity-mismatch' }
-    case 'no_handle':
-      return { kind: 'INERT', reason: 'no-handle' }
-  }
-  return unreachable(vault)
-}
-
-function evaluateGone(vault: VaultCustodyState): CustodyVerdict {
-  switch (vault) {
-    case 'serves':
-      return { kind: 'VAULT', installTombstone: true }
-    case 'cold':
-      return { kind: 'INERT', reason: 'vault-cold', installTombstone: true }
-    case 'needs_reauth':
-      return { kind: 'INERT', reason: 'vault-reauth', installTombstone: true }
-    case 'identity_mismatch':
-      return { kind: 'INERT', reason: 'identity-mismatch' }
-    case 'no_handle':
-      return { kind: 'INERT', reason: 'no-handle' }
-  }
-  return unreachable(vault)
-}
-
-function evaluateSlotAbsent(vault: VaultCustodyState): CustodyVerdict {
-  switch (vault) {
-    case 'serves':
-    case 'cold':
-    case 'needs_reauth':
-      return { kind: 'INERT', reason: 'takeover-incomplete/slot-absent' }
-    case 'identity_mismatch':
-      return { kind: 'INERT', reason: 'identity-mismatch' }
-    case 'no_handle':
-      return { kind: 'INERT', reason: 'no-handle' }
-  }
-  return unreachable(vault)
-}
-
-function evaluatePresentClaustrum(
-  local: LocalCustodyState,
-  vault: VaultCustodyState,
-  fingerprintMatch: boolean | undefined,
-): CustodyVerdict {
-  switch (local) {
-    case 'tombstone':
-    case 'empty':
-      return evaluateTombstone(local, vault)
-    case 'real':
-      return evaluateReal(vault, fingerprintMatch)
-    case 'gone':
-      return evaluateGone(vault)
-    case 'slot-absent':
-      return evaluateSlotAbsent(vault)
-  }
-  return unreachable(local)
-}
-
-export function evaluateCustodyStartup(
-  input: EvaluateCustodyStartupInput,
-): CustodyVerdict {
-  if (input.manifest === 'unreadable') {
-    return { kind: 'INERT', reason: 'manifest-unreadable' }
-  }
-
-  switch (input.mode) {
-    case 'local':
-      return input.manifest === 'present'
-        ? evaluateLocalWithBinding(input.local, input.verifiedInProcessLogin)
-        : evaluateLocal(input.local)
-    case 'claustrum':
-      if (input.manifest === 'absent') {
-        return evaluateUnboundClaustrum(input.local)
-      }
-      if (input.manifest === 'present') {
-        return evaluatePresentClaustrum(
-          input.local,
-          input.vault(),
-          input.fingerprintMatch,
-        )
-      }
-      return unreachable(input.manifest)
-  }
-  return unreachable(input.mode)
-}