@cortexkit/opencode-antigravity-auth 1.0.1 → 2.0.0

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

@@ -0,0 +1,143 @@
+import { randomBytes } from 'node:crypto'
+import {
+  chmod,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  unlink,
+  writeFile,
+} from 'node:fs/promises'
+import { join } from 'node:path'
+
+export interface PortFileEntry {
+  port: number
+  token: string
+  pid: number
+  startedAt: number
+}
+
+const PORT_FILE_PATTERN = /^port-(\d+)\.json$/
+const DIR_MODE = 0o700
+const FILE_MODE = 0o600
+
+export async function writePortFile(
+  dir: string,
+  entry: { port: number; token: string; pid: number },
+): Promise<string> {
+  assertPortFileEntry({ ...entry, startedAt: 0 }, entry.pid)
+
+  // mkdir recursive with the private mode on first creation; on a re-run the
+  // directory already exists with the right mode. We still re-apply chmod so
+  // an operator who widened the directory accidentally gets it repaired
+  // back to 0o700 before we drop a token-bearing file inside.
+  await mkdir(dir, { recursive: true, mode: DIR_MODE })
+  await chmod(dir, DIR_MODE)
+
+  const full: PortFileEntry = { ...entry, startedAt: Date.now() }
+  const target = join(dir, `port-${entry.pid}.json`)
+  const temporary = `${target}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`
+
+  try {
+    await writeFile(temporary, JSON.stringify(full), {
+      encoding: 'utf8',
+      mode: FILE_MODE,
+    })
+    await chmod(temporary, FILE_MODE)
+    await rename(temporary, target)
+  } catch (error) {
+    try {
+      await unlink(temporary)
+    } catch {}
+    throw error
+  }
+  return target
+}
+
+export async function discoverPortFile(
+  dir: string,
+  expectedPid?: number,
+): Promise<PortFileEntry | null> {
+  let names: string[]
+  try {
+    names = await readdir(dir)
+  } catch (error) {
+    if (isNodeError(error, 'ENOENT')) return null
+    throw error
+  }
+
+  const live: PortFileEntry[] = []
+  for (const name of names) {
+    const match = PORT_FILE_PATTERN.exec(name)
+    if (!match) continue
+    const path = join(dir, name)
+    const filenamePid = Number(match[1])
+
+    let parsed: PortFileEntry
+    try {
+      const text = await readFile(path, 'utf8')
+      const raw = JSON.parse(text) as unknown
+      assertPortFileEntry(raw, filenamePid)
+      parsed = raw
+    } catch {
+      // Malformed or stale — keep the directory clean so future discovers
+      // don't trip over the same debris.
+      await unlink(path).catch(() => {})
+      continue
+    }
+
+    if (!isProcessAlive(parsed.pid)) {
+      await unlink(path).catch(() => {})
+      continue
+    }
+
+    live.push(parsed)
+  }
+
+  if (expectedPid !== undefined) {
+    // antigravity exact-PID safety: a missing expected PID must surface as
+    // null so a stale but live entry can't impersonate the requester.
+    return live.find(({ pid }) => pid === expectedPid) ?? null
+  }
+
+  if (live.length === 0) return null
+  live.sort((left, right) => right.startedAt - left.startedAt)
+  return live[0] ?? null
+}
+
+function assertPortFileEntry(
+  value: unknown,
+  filenamePid: number,
+): asserts value is PortFileEntry {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    !Number.isSafeInteger((value as PortFileEntry).pid) ||
+    (value as PortFileEntry).pid <= 0 ||
+    (value as PortFileEntry).pid !== filenamePid ||
+    !Number.isSafeInteger((value as PortFileEntry).port) ||
+    (value as PortFileEntry).port <= 0 ||
+    (value as PortFileEntry).port > 65_535 ||
+    typeof (value as PortFileEntry).token !== 'string' ||
+    (value as PortFileEntry).token.length === 0
+  ) {
+    throw new Error('Invalid RPC port file')
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return isNodeError(error, 'EPERM')
+  }
+}
+
+function isNodeError(error: unknown, code: string): boolean {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error as NodeJS.ErrnoException).code === code
+  )
+}

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

@@ -0,0 +1,31 @@
+export type CommandModalName =
+  | 'antigravity-quota'
+  | 'antigravity-account'
+  | 'antigravity-routing'
+  | 'antigravity-killswitch'
+  | 'antigravity-dump'
+  | 'antigravity-logging'
+
+export interface OpenDialogPayload {
+  command: CommandModalName
+  text: string
+  knobs: Record<string, unknown>
+}
+
+export interface RpcNotification {
+  id: number
+  type: 'open-dialog'
+  payload: OpenDialogPayload
+  sessionId?: string
+}
+
+export interface ApplyRequest {
+  command: CommandModalName
+  arguments: string
+  sessionId?: string
+}
+
+export interface ApplyResult {
+  text: string
+  knobs: Record<string, unknown>
+}

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

@@ -0,0 +1,102 @@
+// Subpath import (not the barrel): this module ships into the TUI's
+// compiled tree, which must not pull the credential-bearing barrel into
+// the host's render path.
+import { fetchWithActiveTimeout } from '@cortexkit/antigravity-auth-core/fetch-timeout'
+
+import { discoverPortFile } from './port-file'
+import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol'
+
+const DEFAULT_TIMEOUT_MS = 2_000
+
+const APPLY_FALLBACK: ApplyResult = { text: 'apply failed', knobs: {} }
+const PENDING_FALLBACK: RpcNotification[] = []
+
+export interface RpcRequestOptions {
+  timeoutMs?: number
+}
+
+export interface RpcClient {
+  apply(
+    request: ApplyRequest,
+    options?: RpcRequestOptions,
+  ): Promise<ApplyResult>
+  pendingNotifications(
+    lastReceivedId: number,
+    sessionId?: string,
+    options?: RpcRequestOptions,
+  ): Promise<RpcNotification[]>
+}
+
+export function createRpcClient(dir: string, expectedPid?: number): RpcClient {
+  return {
+    async apply(request, options) {
+      const result = await post<ApplyResult>(
+        dir,
+        expectedPid,
+        '/rpc/apply',
+        request,
+        options,
+      )
+      return result ?? APPLY_FALLBACK
+    },
+    async pendingNotifications(lastReceivedId, sessionId, options) {
+      const result = await post<{ messages: RpcNotification[] }>(
+        dir,
+        expectedPid,
+        '/rpc/pending-notifications',
+        {
+          lastReceivedId,
+          ...(sessionId === undefined ? {} : { sessionId }),
+        },
+        options,
+      )
+      return result?.messages ?? PENDING_FALLBACK
+    },
+  }
+}
+
+async function post<T>(
+  dir: string,
+  expectedPid: number | undefined,
+  path: string,
+  body: unknown,
+  options: RpcRequestOptions | undefined,
+): Promise<T | null> {
+  // Internal nullable — every RPC call site (apply, pending) must absorb a
+  // missing/unreachable server gracefully. The TUI render path never
+  // crashes because the server is dead; the user sees a fallback text and
+  // a fresh poll retries the next tick.
+  const entry = await discoverPortFileSafe(dir, expectedPid)
+  if (!entry) return null
+
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  try {
+    const response = await fetchWithActiveTimeout(
+      `http://127.0.0.1:${entry.port}${path}`,
+      {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${entry.token}`,
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      },
+      { timeoutMs },
+    )
+    if (!response.ok) return null
+    return (await response.json()) as T
+  } catch {
+    return null
+  }
+}
+
+async function discoverPortFileSafe(
+  dir: string,
+  expectedPid: number | undefined,
+): Promise<Awaited<ReturnType<typeof discoverPortFile>>> {
+  try {
+    return await discoverPortFile(dir, expectedPid)
+  } catch {
+    return null
+  }
+}

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

@@ -0,0 +1,24 @@
+import { createHash } from 'node:crypto'
+import { homedir, tmpdir } from 'node:os'
+import { isAbsolute, join, resolve } from 'node:path'
+
+const RPC_DIR_ENV = 'ANTIGRAVITY_AUTH_RPC_DIR'
+
+// 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()
+  if (override) {
+    return isAbsolute(override) ? override : resolve(projectDirectory, override)
+  }
+
+  const projectHash = createHash('sha256')
+    .update(resolve(projectDirectory))
+    .digest('hex')
+    .slice(0, 16)
+  const stateHome =
+    process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state')
+
+  return join(stateHome, 'cortexkit', 'antigravity-auth', 'rpc', projectHash)
+}
+
+export { tmpdir }