@cortexkit/opencode-antigravity-auth 1.0.1 → 2.0.0

package/src/tui/entry.mjs

@@ -0,0 +1,74 @@
+// Host-aware loader for the Antigravity TUI.
+//
+// Production OpenTUI hosts compile plugin source through
+// `@opentui/solid/scripts/solid-transform` and resolve module imports
+// through a virtual runtime module identifier:
+//
+//   opentui:runtime-module:<encodeURIComponent('@opentui/solid')>
+//
+// When the host has installed that virtual resolver, importing via it gives
+// back the transformed runtime that the host's precompiler emitted; otherwise
+// Bun resolves `@opentui/solid` to the node-exported JS and the host's
+// pre-built `../tui-compiled/tui.tsx` file (which already references those
+// virtual modules in its import graph) lines up correctly.
+//
+// Two import paths are tried, in order:
+//
+//   1. `../tui-compiled/tui.tsx` — the precompiled, virtual-runtime-aware
+//      bundle. Resolved successfully by hosts that ship a runtime module
+//      resolver + the precompiled tree.
+//   2. `../tui.tsx` — the dev fallback. Local development with raw TSX
+//      runs through `@opentui/solid/preload`, which installs the Solid
+//      transform plugin so the same `/** @jsxImportSource @opentui/solid */`
+//      pragma is honoured on the fly.
+//
+// Errors raised while probing for the runtime module that indicate "module
+// not found" are swallowed and the compiled tree is attempted next. Any
+// other error (syntax error, runtime error in the compiled file, etc.) is
+// re-thrown — those are real bugs, not configuration mismatches.
+
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const RUNTIME_MODULE_ID = `opentui:runtime-module:${encodeURIComponent('@opentui/solid')}`
+const ENTRY_DIR = dirname(fileURLToPath(import.meta.url))
+const COMPILED_ENTRY = pathToFileURL(
+  resolve(ENTRY_DIR, '../tui-compiled/tui.tsx'),
+).href
+const RAW_ENTRY = pathToFileURL(resolve(ENTRY_DIR, '../tui.tsx')).href
+
+function isMissingModuleError(error) {
+  if (!error) return false
+  const code =
+    typeof error === 'object' && 'code' in error ? error.code : undefined
+  if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND')
+    return true
+  const message = typeof error.message === 'string' ? error.message : ''
+  return /cannot find module|module not found|ENOENT/i.test(message)
+}
+
+async function probeVirtualRuntime() {
+  try {
+    await import(RUNTIME_MODULE_ID)
+    return true
+  } catch (error) {
+    if (isMissingModuleError(error)) return false
+    throw error
+  }
+}
+
+async function importWithFallback() {
+  const compiledAvailable = await probeVirtualRuntime()
+  if (compiledAvailable) {
+    return import(COMPILED_ENTRY)
+  }
+  return import(RAW_ENTRY)
+}
+
+const mod = await importWithFallback()
+
+// Pass the wrapped plugin shape through unchanged. `tui.tsx` exports the
+// fleet-shape `{ id, tui }` wrapper as its default export; this file just
+// selects between the precompiled and the dev-TSX entry, it does not
+// re-wrap.
+export default mod?.default ?? mod?.tui ?? mod

package/src/tui/file-logger.ts

@@ -0,0 +1,145 @@
+/**
+ * File-backed logger for the OpenTUI sidebar tree.
+ *
+ * The TUI renders directly into the host terminal. Any stray write to the
+ * terminal from inside the render path (or any module it imports) corrupts
+ * the frame buffer — a single byte out of place shoves every subsequent
+ * cell right and breaks the sidebar.
+ *
+ * This logger writes to a rotating file under the host's log directory and
+ * never touches stdout/stderr. The plugin already wires up the same kind of
+ * file logger via `debug.ts`; the sidebar gets its own file so log lines
+ * from this tree are easy to attribute.
+ */
+
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export type TuiLogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+export interface TuiLogger {
+  debug(message: string, extra?: Record<string, unknown>): void
+  info(message: string, extra?: Record<string, unknown>): void
+  warn(message: string, extra?: Record<string, unknown>): void
+  error(message: string, extra?: Record<string, unknown>): void
+  /** Resolve the path the logger writes to. `undefined` when file logging is disabled. */
+  getLogPath(): string | undefined
+}
+
+const LOG_PREFIX = '[opencode-antigravity-auth/tui]'
+const DEFAULT_MAX_BYTES = 1_000_000
+const MAX_KEEP_LINES = 200
+/**
+ * Owner-read/write only — matches the rest of the plugin's on-disk
+ * sensitive state (account storage, signature cache). Windows ignores
+ * POSIX mode bits so the assertion in the test is best-effort there.
+ */
+const FILE_MODE = 0o600
+
+interface FileLoggerOptions {
+  filePath: string
+  maxBytes?: number
+}
+
+/**
+ * Resolve the on-disk path for the TUI's log file.
+ *
+ * - `ANTIGRAVITY_AUTH_TUI_LOG_FILE` wins when set (used by tests so they
+ *   never touch a real user log file).
+ * - Otherwise write under `<xdg-state>/cortexkit/antigravity-auth/tui.log`.
+ *
+ * Falls back to a temp file when the host path cannot be resolved (e.g. no
+ * home directory on a hostile CI box); the file logger itself never throws,
+ * it just drops the line.
+ */
+export function resolveTuiLogPath(): string {
+  const override = process.env.ANTIGRAVITY_AUTH_TUI_LOG_FILE
+  if (override && override.trim().length > 0) return override
+  const base = process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state')
+  return join(base, 'cortexkit', 'antigravity-auth', 'tui.log')
+}
+
+export function createTuiFileLogger(
+  options?: Partial<FileLoggerOptions>,
+): TuiLogger {
+  const filePath = options?.filePath ?? resolveTuiLogPath()
+  const maxBytes = options?.maxBytes ?? DEFAULT_MAX_BYTES
+  return createFileLogger({ filePath, maxBytes })
+}
+
+function createFileLogger(options: FileLoggerOptions): TuiLogger {
+  const { filePath, maxBytes = DEFAULT_MAX_BYTES } = options
+
+  const rotateIfNeeded = (): void => {
+    try {
+      if (!existsSync(filePath)) return
+      const stat = statSync(filePath)
+      if (stat.size < maxBytes) return
+      // Tail-truncate: keep the last MAX_KEEP_LINES, drop the rest. Cheap,
+      // bounded, and good enough for a sidecar debug stream.
+      const text = readFileSync(filePath, 'utf-8')
+      const lines = text.split('\n')
+      const keepFrom = Math.max(0, lines.length - MAX_KEEP_LINES)
+      const tail = lines.slice(keepFrom).join('\n')
+      writeFileSync(filePath, tail, 'utf-8')
+      // `writeFileSync` over an existing file keeps its mode; we rotate
+      // the file specifically to enforce owner-only access, so re-assert
+      // the mode after the truncation.
+      chmodSync(filePath, FILE_MODE)
+    } catch {
+      // Best-effort; ignore rotation errors.
+    }
+  }
+
+  const write = (
+    level: TuiLogLevel,
+    message: string,
+    extra?: Record<string, unknown>,
+  ): void => {
+    try {
+      rotateIfNeeded()
+      // Enforce 0o700 on the parent directory even when it already
+      // exists — `mkdirSync({ recursive: true, mode })` only sets the
+      // mode on the leaf directory it creates, so an existing leaky
+      // directory would keep its old mode. The post-hoc chmodSync
+      // closes the gap.
+      mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 })
+      chmodSync(dirname(filePath), 0o700)
+      const payload: Record<string, unknown> = {
+        ts: Date.now(),
+        level,
+        message,
+      }
+      if (extra && Object.keys(extra).length > 0) payload.extra = extra
+      // `mode: 0o600` so the log file is owner-only — the same default the
+      // plugin's account storage applies. `appendFileSync` only honours the
+      // mode flag when the file is created, so existing files keep whatever
+      // mode they had. `chmodSync` below re-asserts the mode after every
+      // append so a leaked-permissions file is repaired on the next write.
+      appendFileSync(filePath, `${LOG_PREFIX} ${JSON.stringify(payload)}\n`, {
+        encoding: 'utf-8',
+        mode: FILE_MODE,
+      })
+      chmodSync(filePath, FILE_MODE)
+    } catch {
+      // Drop the line — file logging must never throw into the render path.
+    }
+  }
+
+  return {
+    debug: (message, extra) => write('debug', message, extra),
+    info: (message, extra) => write('info', message, extra),
+    warn: (message, extra) => write('warn', message, extra),
+    error: (message, extra) => write('error', message, extra),
+    getLogPath: () => filePath,
+  }
+}