@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

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

package/src/tui-compiled/runtime/rpc-port-file.ts

@@ -1,177 +0,0 @@
-import type { Dirent } from 'node:fs'
-import {
-  chmod,
-  mkdir,
-  readdir,
-  readFile,
-  rename,
-  rmdir,
-  unlink,
-  writeFile,
-} from 'node:fs/promises'
-import { join, resolve } from 'node:path'
-import { createLogger } from './logger.ts'
-
-const log = createLogger('rpc')
-
-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'
-  }
-}
-
-function isManagedRpcStateDir(name: string): boolean {
-  return /^(?:openai-auth-)?[0-9a-f]{16}$/.test(name)
-}
-
-function isUsablePortFileEntry(value: unknown): value is PortFileEntry {
-  return (
-    value !== null &&
-    typeof value === 'object' &&
-    !Array.isArray(value) &&
-    typeof (value as { pid?: unknown }).pid === 'number' &&
-    Number.isFinite((value as { pid: number }).pid) &&
-    typeof (value as { port?: unknown }).port === 'number' &&
-    Number.isFinite((value as { port: number }).port)
-  )
-}
-
-async function removeCorruptPortFile(portFile: string): Promise<void> {
-  log.debug('rpc corrupt port file', { pid: process.pid, portFile })
-  await unlink(portFile).catch(() => {})
-}
-
-export async function writePortFile(
-  dir: string,
-  entry: { port: number; token: string; pid: number },
-  options: {
-    secureDir?: boolean
-    beforeWrite?: () => void | Promise<void>
-  } = {},
-): Promise<string> {
-  // The directory can be removed by another project's sweep between our
-  // mkdir and the first writeFile/rename, so the whole create-then-rename
-  // unit is retried once on ENOENT. The retry recreates the directory; a
-  // persistent ENOENT (e.g. permission, read-only parent) will surface on
-  // the second attempt — failing fast beats an unbounded loop.
-  const writeOnce = async (): Promise<string> => {
-    await mkdir(dir, {
-      recursive: true,
-      mode: options.secureDir ? 0o700 : undefined,
-    })
-    if (options.secureDir) await chmod(dir, 0o700)
-    await options.beforeWrite?.()
-    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
-  }
-  try {
-    return await writeOnce()
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return await writeOnce()
-    }
-    throw error
-  }
-}
-
-export async function sweepRpcState(
-  root: string,
-  activeDir: string,
-): Promise<void> {
-  let projectDirs: Dirent<string>[]
-  try {
-    projectDirs = await readdir(root, { withFileTypes: true })
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return
-    throw error
-  }
-
-  const active = resolve(activeDir)
-  for (const projectDir of projectDirs) {
-    if (!projectDir.isDirectory() || !isManagedRpcStateDir(projectDir.name)) {
-      continue
-    }
-    const dir = join(root, projectDir.name)
-    let names: string[]
-    try {
-      names = await readdir(dir)
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue
-      throw error
-    }
-    for (const name of names) {
-      if (!name.startsWith('port-') || !name.endsWith('.json')) continue
-      const portFile = join(dir, name)
-      let raw: string | undefined
-      try {
-        raw = await readFile(portFile, 'utf8')
-      } catch {
-        continue
-      }
-      if (raw === undefined) continue
-      let parsed: unknown
-      try {
-        parsed = JSON.parse(raw)
-      } catch {
-        await removeCorruptPortFile(portFile)
-        continue
-      }
-      if (!isUsablePortFileEntry(parsed)) {
-        await removeCorruptPortFile(portFile)
-        continue
-      }
-      const entry = parsed
-      if (!pidAlive(entry.pid)) await unlink(portFile).catch(() => {})
-    }
-    if (resolve(dir) !== active) await rmdir(dir).catch(() => {})
-  }
-}
-
-export async function discoverPortFile(
-  dir: string,
-  expectedPid?: number,
-): 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
-  const candidates =
-    expectedPid !== undefined && expectedPid >= 1
-      ? live.filter((entry) => entry.pid === expectedPid)
-      : []
-  const entries = candidates.length > 0 ? candidates : live
-  return entries.sort((a, b) => b.startedAt - a.startedAt)[0] ?? null
-}

package/src/tui-compiled/runtime/rpc-protocol.ts

@@ -1,12 +0,0 @@
-/**
- * The RPC payload types now live in the shared core, because both hosts build
- * the same payloads. This file stays on disk as a re-export so the existing
- * build entry and every importer that names `rpc/protocol` keep working.
- */
-export type {
-  ApplyRequest,
-  ApplyResult,
-  CommandModalName,
-  OpenDialogPayload,
-  RpcNotification,
-} from '../shared/internal.ts'

package/src/tui-compiled/runtime/rpc-rpc-client.ts

@@ -1,82 +0,0 @@
-import { discoverPortFile, type PortFileEntry } from './rpc-port-file.ts'
-import type { ApplyRequest, ApplyResult, RpcNotification } from './rpc-protocol.ts'
-
-export interface RpcClient {
-  pending: (
-    lastReceivedId: number,
-    sessionId?: string,
-  ) => Promise<RpcNotification[]>
-  apply: (request: ApplyRequest, timeoutMs?: number) => Promise<ApplyResult>
-}
-
-export const DEFAULT_RPC_TIMEOUT_MS = 2_000
-
-async function call<T>(
-  dir: string,
-  expectedPid: number | undefined,
-  onSelected: ((entry: PortFileEntry | null) => void) | undefined,
-  method: string,
-  params: Record<string, unknown>,
-  timeoutMs = DEFAULT_RPC_TIMEOUT_MS,
-): Promise<T | null> {
-  const entry = await discoverPortFile(dir, expectedPid)
-  onSelected?.(entry)
-  if (!entry) return null
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), timeoutMs)
-  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,
-  expectedPid?: number,
-  onSelected?: (entry: PortFileEntry | null) => void,
-): RpcClient {
-  let reportedSelection = false
-  const reportSelected = (entry: PortFileEntry | null) => {
-    if (reportedSelection) return
-    reportedSelection = true
-    onSelected?.(entry)
-  }
-  return {
-    async pending(lastReceivedId, sessionId) {
-      const out = await call<{ messages: RpcNotification[] }>(
-        dir,
-        expectedPid,
-        reportSelected,
-        'pending-notifications',
-        { lastReceivedId, sessionId },
-      )
-      return out?.messages ?? []
-    },
-    async apply(request, timeoutMs) {
-      const out = await call<ApplyResult>(
-        dir,
-        expectedPid,
-        reportSelected,
-        'apply',
-        {
-          ...request,
-        },
-        timeoutMs,
-      )
-      return out ?? { text: 'apply failed', knobs: {} }
-    },
-  }
-}

package/src/tui-compiled/runtime/rpc-rpc-dir.ts

@@ -1,46 +0,0 @@
-import { createHash } from 'node:crypto'
-import { homedir, tmpdir } from 'node:os'
-import { dirname, join, resolve } from 'node:path'
-
-const RPC_DIR_ENV = 'OPENCODE_OPENAI_AUTH_RPC_DIR'
-
-export interface RpcDirResolution {
-  dir: string
-  secureDir: boolean
-  sweepRoot?: string
-}
-
-function rpcHash(projectDirectory: string): string {
-  return createHash('sha256')
-    .update(projectDirectory)
-    .digest('hex')
-    .slice(0, 16)
-}
-
-function defaultRpcRoot(): string {
-  const base = process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state')
-  return join(base, 'cortexkit', 'openai-auth', 'rpc')
-}
-
-// 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)
-  return join(defaultRpcRoot(), `openai-auth-${rpcHash(projectDirectory)}`)
-}
-
-export async function resolveRpcDir(
-  projectDirectory: string,
-): Promise<RpcDirResolution> {
-  const override = process.env[RPC_DIR_ENV]?.trim()
-  if (override) {
-    return { dir: resolve(projectDirectory, override), secureDir: false }
-  }
-  const dir = getRpcDir(projectDirectory)
-  return { dir, secureDir: true, sweepRoot: dirname(dir) }
-}
-
-export { tmpdir }