@cortexkit/opencode-openai-auth 0.11.0 → 1.0.0

package/src/tui-compiled/runtime/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/shared/internal.ts

@@ -1,6 +0,0 @@
-// Generated by scripts/build-tui.ts. Do not edit.
-export * from './logger.ts'
-export * from './paths.ts'
-export * from './refresh-file-lock.ts'
-export * from './util/error.ts'
-export * from './util/open-url.ts'

package/src/tui-compiled/shared/logger.ts

@@ -1,264 +0,0 @@
-import {
-  appendFileSync,
-  chmodSync,
-  existsSync,
-  renameSync,
-  statSync,
-} from 'node:fs'
-
-export type Level = 'error' | 'warn' | 'info' | 'debug' | 'trace'
-const ORDER: Record<Level, number> = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4,
-}
-const MAX_BYTES = 5 * 1024 * 1024
-
-/**
- * Where lines are written, and the level floor, as the host supplied them.
- *
- * Both start unset. A host decides where its log lives — that decision reads
- * host environment variables and host directories, neither of which belongs in
- * shared code — and calls `initLogger` before it runs any command. Until then
- * every `log.*` call is a silent no-op: throwing would turn the first command a
- * host forgot to wire into a crash, and buffering would hold credential-bearing
- * lines for an init that may never arrive.
- */
-let logFileSource: string | (() => string) | undefined
-let initLevelSource: Level | (() => Level | undefined) | undefined
-let runtimeLevel: Level | undefined
-
-export interface InitLoggerOptions {
-  /**
-   * Path of the file lines are appended to, or a function returning it.
-   *
-   * A function is what a host passes when its destination can move while the
-   * process runs — an operator or a test changing the variable that names the
-   * log file expects the next line to land in the new file, and a value
-   * captured once at init would keep writing to the old one.
-   */
-  file: string | (() => string)
-  /** Level floor applied when no `setLogLevel` call has overridden it. */
-  level?: Level | (() => Level | undefined)
-}
-
-/**
- * Point the logger at a host's file and level. Idempotent: calling it again
- * replaces both. A runtime level installed by `setLogLevel` is deliberately
- * left alone, because it is the operator's explicit choice and outranks the
- * floor a host computed at start-up.
- */
-export function initLogger(options: InitLoggerOptions): void {
-  logFileSource = options.file
-  initLevelSource = options.level
-}
-
-export function setLogLevel(l: Level | undefined) {
-  if (l === undefined || l in ORDER) runtimeLevel = l
-}
-
-function logFilePath(): string | undefined {
-  if (logFileSource === undefined) return undefined
-  const resolved =
-    typeof logFileSource === 'function' ? logFileSource() : logFileSource
-  return resolved || undefined
-}
-
-function configuredLevel(): Level {
-  if (runtimeLevel) return runtimeLevel
-  const floor =
-    typeof initLevelSource === 'function' ? initLevelSource() : initLevelSource
-  if (floor && floor in ORDER) return floor
-  return 'info'
-}
-
-const SECRET_KEY_EXACT =
-  /^(authorization|x-api-key|cookie|set-cookie|refresh|access|token)$/i
-function isSecretKey(key: string): boolean {
-  if (SECRET_KEY_EXACT.test(key)) return true
-  const k = key.toLowerCase().replace(/[-_]/g, '')
-  // Only the unambiguous ChatGPT stable id (chatgpt-account-id / chatgptAccountId)
-  // is sensitive. A bare `accountId` field is overloaded — most diagnostic logs put
-  // the INTERNAL account id/key ('main' or a fallback id) there, which is safe and
-  // needed for debugging — so it is intentionally NOT redacted by name. The genuine
-  // ChatGPT id is kept out of logs at the source instead.
-  if (k === 'chatgptaccountid') return true
-  // Operator identity carried on a served vault credential. These arrived with
-  // the client widening that added `accountId`/`email`/`orgName`/`projectId`;
-  // they are personal data with no diagnostic value, so they never reach a log
-  // file. The structural guard is not logging a served credential wholesale —
-  // this list only closes the fields that exist today.
-  if (k === 'email' || k === 'orgname' || k === 'organizationname') return true
-  if (k.includes('apikey')) return true
-  if (k.endsWith('secret') || k.endsWith('password')) return true
-  if (k.endsWith('token') && !k.endsWith('tokens')) return true
-  return false
-}
-const TOKEN_VALUE =
-  /\b(Bearer\s+[\w.-]+|sk-[\w-]+|eyJ[\w.-]+)\b|ckh_[A-Za-z0-9_-]{20,}/g
-export function redact(value: unknown): unknown {
-  return redactInner(value, new WeakSet<object>())
-}
-
-/**
- * Scrub credential-shaped strings without redacting by key name.
- *
- * For regions where a key names a piece of data rather than holding a secret —
- * a JSON Schema property called `api_key` describes an argument, it does not
- * carry one — replacing the node by name destroys the structure while removing
- * nothing sensitive. A credential pasted into a description is still caught,
- * because that is a string.
- */
-export function redactStrings(value: unknown): unknown {
-  return redactStringsInner(value, new WeakSet<object>())
-}
-
-function redactStringsInner(value: unknown, seen: WeakSet<object>): unknown {
-  if (typeof value === 'string')
-    return value.replace(TOKEN_VALUE, '***REDACTED***')
-  if (Array.isArray(value)) {
-    if (seen.has(value)) return '[Circular]'
-    seen.add(value)
-    const arr = value.map((v) => redactStringsInner(v, seen))
-    seen.delete(value)
-    return arr
-  }
-  if (value && typeof value === 'object') {
-    if (seen.has(value)) return '[Circular]'
-    seen.add(value)
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(value))
-      out[k] = redactStringsInner(v, seen)
-    seen.delete(value)
-    return out
-  }
-  return value
-}
-function redactInner(value: unknown, seen: WeakSet<object>): unknown {
-  if (typeof value === 'string')
-    return value.replace(TOKEN_VALUE, '***REDACTED***')
-  if (Array.isArray(value)) {
-    if (seen.has(value)) return '[Circular]'
-    seen.add(value)
-    const arr = value.map((v) => redactInner(v, seen))
-    seen.delete(value)
-    return arr
-  }
-  if (value && typeof value === 'object') {
-    if (seen.has(value)) return '[Circular]'
-    seen.add(value)
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(value))
-      out[k] = isSecretKey(k) ? '***REDACTED***' : redactInner(v, seen)
-    seen.delete(value)
-    return out
-  }
-  return value
-}
-
-let buffer: string[] = []
-let timer: ReturnType<typeof setTimeout> | undefined
-const ROTATE_KEEP = 3
-function chmodPrivate(path: string) {
-  try {
-    chmodSync(path, 0o600)
-  } catch {
-    /* never throw */
-  }
-}
-function rotateIfNeeded(f: string) {
-  try {
-    if (!(existsSync(f) && statSync(f).size > MAX_BYTES)) return
-    for (let i = ROTATE_KEEP - 1; i >= 1; i--) {
-      if (existsSync(`${f}.${i}`)) {
-        const rotated = `${f}.${i + 1}`
-        renameSync(`${f}.${i}`, rotated)
-        chmodPrivate(rotated)
-      }
-    }
-    const rotated = `${f}.1`
-    renameSync(f, rotated)
-    chmodPrivate(rotated)
-  } catch {
-    /* never throw */
-  }
-}
-
-/**
- * Write whatever is buffered. Safe to call synchronously from a process-exit
- * handler, which is how each host drains the buffer on shutdown.
- */
-export function flushLogs() {
-  if (!buffer.length) return
-  const file = logFilePath()
-  const text = buffer.join('')
-  buffer = []
-  if (!file) return
-  try {
-    rotateIfNeeded(file)
-    if (existsSync(file)) chmodPrivate(file)
-    appendFileSync(file, text, { encoding: 'utf8', mode: 0o600 })
-  } catch {
-    /* never throw */
-  }
-}
-function schedule() {
-  if (!timer)
-    timer = setTimeout(() => {
-      timer = undefined
-      flushLogs()
-    }, 500)
-}
-
-function safeSerialize(data: unknown): string {
-  try {
-    return ` ${JSON.stringify(redact(data))}`
-  } catch {
-    return ' [unserializable]'
-  }
-}
-
-function emit(channel: string, level: Level, message: string, data?: unknown) {
-  // No destination means no host has initialised the logger. Drop the line
-  // rather than buffering it: see the note on logFileSource above.
-  if (logFileSource === undefined) return
-  if (ORDER[level] > ORDER[configuredLevel()]) return
-  const line =
-    `[${new Date().toISOString()}] ${level.toUpperCase()} [${channel}] ${redactStrings(message)}` +
-    (data === undefined ? '' : safeSerialize(data)) +
-    '\n'
-  buffer.push(line)
-  if (buffer.length >= 50) flushLogs()
-  else schedule()
-}
-
-export function createLogger(channel: string) {
-  return {
-    error: (m: string, d?: unknown) => emit(channel, 'error', m, d),
-    warn: (m: string, d?: unknown) => emit(channel, 'warn', m, d),
-    info: (m: string, d?: unknown) => emit(channel, 'info', m, d),
-    debug: (m: string, d?: unknown) => emit(channel, 'debug', m, d),
-    trace: (m: string, d?: unknown) => emit(channel, 'trace', m, d),
-  }
-}
-export async function flushForTest() {
-  flushLogs()
-}
-
-/**
- * Return the logger to its uninitialised state. Only a test needs this: a
- * single process runs every test file, so a file path left over from one test
- * would keep a later "logger was never initialised" case writing lines.
- */
-export function resetLoggerForTest() {
-  buffer = []
-  if (timer) {
-    clearTimeout(timer)
-    timer = undefined
-  }
-  logFileSource = undefined
-  initLevelSource = undefined
-  runtimeLevel = undefined
-}

package/src/tui-compiled/shared/paths.ts

@@ -1,33 +0,0 @@
-/**
- * Pure path values shared by every host.
- *
- * Nothing here reads an environment variable or knows where a host keeps its
- * configuration. A host resolves its own two file paths and hands them to the
- * store as an `AccountPaths`; the only thing that must not drift between hosts
- * is the file name itself, which is why the constants live here rather than in
- * each host's own resolver.
- */
-
-import { basename, dirname, join } from 'node:path'
-
-export const ACCOUNT_FILE_NAME = 'openai-auth.json'
-export const ACCOUNT_STATE_FILE_NAME = 'openai-auth-state.json'
-
-/**
- * The config file and the runtime-state file a store operation reads and writes.
- *
- * Both are required. A store function never derives one from the other, because
- * a host may point its state file somewhere the derivation would not reach and
- * a silently derived path would lock one file while writing another.
- */
-export interface AccountPaths {
-  configPath: string
-  statePath: string
-}
-
-/** Derive the state-file path from the config path without reading env vars. */
-export function deriveStatePath(configPath: string): string {
-  return basename(configPath) === ACCOUNT_FILE_NAME
-    ? join(dirname(configPath), ACCOUNT_STATE_FILE_NAME)
-    : `${configPath}.state.json`
-}