@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/dist/quota-normalize-08hpp51v.js

@@ -1 +0,0 @@
-import{lb as a,mb as b,nb as c,ob as d,pb as e}from"./index-hh52v8sb.js";import"./index-9ehhb051.js";export{a as toResetIso,d as normalizeWsFrame,e as normalizeWham,b as normalizeQuotaHeaders,c as isCompleteQuotaHeaderFrame};

package/dist/sidebar-state-CoKYKcLn.d.ts

@@ -1,220 +0,0 @@
-//#region src/core/custody-state.d.ts
-type VaultCustodyState = 'serves' | 'cold' | 'needs_reauth' | 'identity_mismatch' | 'no_handle';
-declare const CUSTODY_INERT_REASONS: readonly ['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'];
-type CustodyInertReason = (typeof CUSTODY_INERT_REASONS)[number];
-type CustodyVerdict = {
-  kind: 'LOCAL';
-} | {
-  kind: 'VAULT';
-  canonicalize?: boolean;
-  installTombstone?: boolean;
-} | {
-  kind: 'INERT';
-  reason: CustodyInertReason;
-  installTombstone?: boolean;
-  canonicalize?: boolean;
-} | {
-  kind: 'NEEDS_LOGIN';
-  reason?: 'corrupt';
-};
-//#endregion
-//#region src/sidebar-state.d.ts
-interface QuotaWindow {
-  usedPercent: number;
-  remainingPercent: number;
-  checkedAt?: number;
-  resetsAt?: string;
-  windowMinutes?: number;
-}
-interface SpendControlReading {
-  limit: number;
-  used: number;
-  remaining: number;
-  usedPercent: number;
-  remainingPercent: number;
-  resetsAt?: string;
-  unit?: string;
-  source?: string;
-  reached: boolean;
-}
-interface AccountQuota {
-  checkedAt?: number;
-  primary?: QuotaWindow;
-  secondary?: QuotaWindow;
-  spendControl?: SpendControlReading;
-  spendControlCleared?: true;
-  resetCreditsAvailable?: number;
-}
-type QuotaWindowKey = 'primary' | 'secondary';
-declare function formatWindowLabel(windowMinutes: number | undefined, fallbackKey: QuotaWindowKey): string;
-interface PresentQuotaWindow {
-  key: QuotaWindowKey;
-  label: string;
-  window: QuotaWindow;
-  windowMs: number | null;
-}
-declare function getPresentQuotaWindows(quota: AccountQuota | null): PresentQuotaWindow[];
-interface SidebarAccountState {
-  id: string;
-  label: string | undefined;
-  /** ChatGPT identity of the account this quota belongs to. */
-  accountId?: string;
-  quota: AccountQuota | null;
-  killed: boolean;
-  enabled: boolean;
-  resetCredits?: number;
-  custody?: SidebarAccountCustody;
-}
-type SidebarCustodyState = 'vault' | 'needsLogin' | 'local' | 'inert';
-type SidebarCustodyReason = CustodyInertReason | 'corrupt';
-interface SidebarAccountCustody {
-  state: SidebarCustodyState;
-  reason?: SidebarCustodyReason;
-  recordVersion?: number;
-}
-interface ActiveRoutingEntry {
-  activeId: string;
-  route: string;
-  updatedAt: number;
-}
-type ActiveRoutingMap = Record<string, ActiveRoutingEntry>;
-interface StickyAssignment {
-  accountId: string;
-  wireAccountId?: string;
-  assignedAt: number;
-  lastSeenAt: number;
-  inputBytes: number;
-  quotaCheckedAt?: number;
-}
-type StickyAssignmentMap = Record<string, StickyAssignment>;
-interface StickyAssignmentChoice {
-  accountId: string;
-  quotaCheckedAt?: number;
-}
-interface ResolveStickyAssignmentInput {
-  sessionId: string;
-  requestBytes: number;
-  now: number;
-  validPinnedAccountIds: readonly string[];
-  excludeAccountIds?: readonly string[];
-  quotaCheckedAtByAccount: Readonly<Record<string, number | undefined>>;
-  wireAccountIdByAccount?: Readonly<Record<string, string | undefined>>;
-  choose: (pendingBytes: ReadonlyMap<string, number>) => StickyAssignmentChoice | undefined;
-}
-interface SidebarState {
-  main: {
-    quota: AccountQuota | null;
-    /** ChatGPT identity of the main account this quota belongs to. */
-    mainAccountId?: string;
-    custody?: SidebarAccountCustody;
-    killed: boolean;
-    quotaBackedOff?: boolean;
-    quotaBackoffUntil?: number;
-    refreshBackedOff?: boolean;
-    refreshBackoffUntil?: number;
-    resetCredits?: number;
-  };
-  fallbacks: SidebarAccountState[];
-  /** @deprecated Compatibility field for readers that do not consume activeRouting. */
-  activeId: string | undefined;
-  /** Machine-global routing mode and compatibility value for older readers. */
-  route: string;
-  activeRouting?: ActiveRoutingMap;
-  stickyAssignments?: StickyAssignmentMap;
-  planType?: string;
-  credits?: number;
-  lastUpdated: number;
-}
-declare const STICKY_ASSIGNMENT_MAX_AGE_MS: number;
-declare const STICKY_ASSIGNMENT_MAX_ENTRIES = 256;
-declare function hashSidebarSessionId(sessionId: string): string;
-declare function getSidebarStateFile(): string;
-declare function projectCustodyForSidebar(verdict: CustodyVerdict): SidebarAccountCustody;
-declare const DEFAULT_SIDEBAR_STATE: SidebarState;
-/**
- * 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.
- */
-declare function normalizeSidebarState(raw: unknown): SidebarState;
-declare function getSidebarState(stateFile?: string): Promise<SidebarState>;
-declare const ACTIVE_ROUTING_MAX_AGE_MS: number;
-declare const ACTIVE_ROUTING_MAX_ENTRIES = 128;
-type SidebarRoutingAccount = {
-  id: string;
-  enabled?: boolean;
-  killed?: boolean;
-};
-declare function isUsableRoutingEntry(entry: ActiveRoutingEntry, accounts: readonly SidebarRoutingAccount[] | undefined, now?: number): boolean;
-declare function spendControlExhaustedResetAt(quota: AccountQuota | null | undefined, now?: number): {
-  resetsAt: string;
-  resetAtMs: number;
-} | undefined;
-declare function exhaustedQuotaResetAt(quota: AccountQuota | null | undefined, now?: number): {
-  resetsAt: string;
-  resetAtMs: number;
-} | undefined;
-declare function isQuotaExhausted(quota: AccountQuota | null | undefined, now?: number): boolean;
-declare function resolveSessionStickyAccount(state: SidebarState, sessionId: string | undefined, now?: number): string | undefined;
-declare function resolveSessionSidebarRouting(state: SidebarState, sessionId?: string, now?: number): {
-  activeId: string;
-  route: string;
-};
-declare function pruneActiveRouting(activeRouting: ActiveRoutingMap | undefined, accounts: readonly SidebarRoutingAccount[] | undefined, now?: number, removedSessionId?: string): ActiveRoutingMap | undefined;
-declare function pruneStickyAssignments(assignments: StickyAssignmentMap | undefined, validAccountIds: ReadonlySet<string> | undefined, now?: number, removedSessionHash?: string): StickyAssignmentMap | undefined;
-interface SidebarMergeHooks {
-  beforeRecheck?: () => void | Promise<void>;
-}
-/**
- * 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).
- */
-declare function setSidebarState(state: SidebarState, file?: string): Promise<void>;
-type SidebarMachineState = Pick<SidebarState, 'main' | 'fallbacks' | 'planType' | 'credits' | 'lastUpdated'> & {
-  route: string;
-};
-declare function setSidebarMachineState(machineState: SidebarMachineState, file?: string, hooks?: SidebarMergeHooks): Promise<void>;
-declare function upsertSidebarActiveRouting(input: {
-  sessionId: string;
-} & ActiveRoutingEntry, accounts: readonly SidebarRoutingAccount[] | undefined, file?: string, hooks?: SidebarMergeHooks): Promise<void>;
-declare function setSidebarLegacyRouting(input: ActiveRoutingEntry, file?: string): Promise<void>;
-declare function removeSidebarActiveRouting(sessionId: string, accounts: readonly SidebarRoutingAccount[] | undefined, file?: string, hooks?: SidebarMergeHooks): Promise<void>;
-declare function resolveSidebarStickyAssignment(input: ResolveStickyAssignmentInput, file?: string, hooks?: SidebarMergeHooks): Promise<StickyAssignment | undefined>;
-declare function clearSidebarStickyAssignment(sessionId: string, file?: string): Promise<boolean>;
-/**
- * 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.
- */
-declare function drainSidebarWrites(): Promise<void>;
-declare function resolveActiveAccount(state: SidebarState): {
-  id: string;
-  name: string;
-  quota: AccountQuota | null;
-  killed: boolean;
-};
-declare function getCollapsedQuotaSummary(quota: AccountQuota | null): {
-  primaryUsedPercent: number | null;
-  secondaryUsedPercent: number | null;
-  text: string | null;
-};
-interface QuotaPacing {
-  pacePercent: number;
-  deltaPercent: number;
-  state: 'deficit' | 'reserve' | 'on-pace';
-  runsOutAt: string | null;
-}
-declare function computeQuotaPacing(window: QuotaWindow, windowMs: number, now: number): QuotaPacing | null;
-//#endregion
-export { getCollapsedQuotaSummary as A, pruneStickyAssignments as B, StickyAssignmentChoice as C, drainSidebarWrites as D, computeQuotaPacing as E, isQuotaExhausted as F, resolveSidebarStickyAssignment as G, resolveActiveAccount as H, isUsableRoutingEntry as I, setSidebarState as J, setSidebarLegacyRouting as K, normalizeSidebarState as L, getSidebarState as M, getSidebarStateFile as N, exhaustedQuotaResetAt as O, hashSidebarSessionId as P, VaultCustodyState as Q, projectCustodyForSidebar as R, StickyAssignment as S, clearSidebarStickyAssignment as T, resolveSessionSidebarRouting as U, removeSidebarActiveRouting as V, resolveSessionStickyAccount as W, upsertSidebarActiveRouting as X, spendControlExhaustedResetAt as Y, CustodyInertReason as Z, SidebarCustodyState as _, ActiveRoutingMap as a, SidebarState as b, QuotaPacing as c, ResolveStickyAssignmentInput as d, STICKY_ASSIGNMENT_MAX_AGE_MS as f, SidebarCustodyReason as g, SidebarAccountState as h, ActiveRoutingEntry as i, getPresentQuotaWindows as j, formatWindowLabel as k, QuotaWindow as l, SidebarAccountCustody as m, ACTIVE_ROUTING_MAX_ENTRIES as n, DEFAULT_SIDEBAR_STATE as o, STICKY_ASSIGNMENT_MAX_ENTRIES as p, setSidebarMachineState as q, AccountQuota as r, PresentQuotaWindow as s, ACTIVE_ROUTING_MAX_AGE_MS as t, QuotaWindowKey as u, SidebarMachineState as v, StickyAssignmentMap as w, SpendControlReading as x, SidebarRoutingAccount as y, pruneActiveRouting as z };

package/dist/token-util-ypgz7rge.js

@@ -1 +0,0 @@
-import{b as a}from"./index-sdt2d2ra.js";import"./index-9ehhb051.js";export default a();

package/src/tui-compiled/raw/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/raw/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)
-}

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

@@ -1,53 +0,0 @@
-/**
- * OpenCode's log destination.
- *
- * The logger itself lives in the shared core so both hosts get the same
- * redaction rules. What stays here is the part that is specific to this host:
- * which file the lines go to, which level floor applies, and when the buffer is
- * drained at process exit. Those are the only three things that read this
- * host's environment variables, and the core reads none.
- *
- * The init runs at module load rather than from one call site because every
- * entry point in this package — the plugin loader, the RPC server, the separate
- * TUI process — reaches the logger through this module, and a core logger no
- * host has initialised silently drops every line. Both values are passed as
- * functions so the destination and level keep resolving on each write, which is
- * what they do today.
- */
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import {
-  flushLogs,
-  initLogger,
-  type Level,
-} from '../shared/internal.ts'
-
-export {
-  createLogger,
-  flushForTest,
-  flushLogs,
-  type Level,
-  redact,
-  redactStrings,
-  setLogLevel,
-} from '../shared/internal.ts'
-
-const LEVELS: readonly Level[] = ['error', 'warn', 'info', 'debug', 'trace']
-
-export function getLogFile(): string {
-  return (
-    process.env.OPENCODE_OPENAI_AUTH_LOG_FILE ??
-    join(tmpdir(), 'opencode-openai-auth.log')
-  )
-}
-
-export function getEnvLogLevel(): Level | undefined {
-  const env = process.env.OPENCODE_OPENAI_AUTH_LOG_LEVEL as Level | undefined
-  return env && LEVELS.includes(env) ? env : undefined
-}
-
-initLogger({ file: getLogFile, level: getEnvLogLevel })
-
-// Under `bun test` the buffer is drained explicitly by the tests that assert on
-// it, and registering a process-wide exit handler per test file is noise.
-if (process.env.NODE_ENV !== 'test') process.on('exit', flushLogs)