@koreanhole/opencodex 2.97.0 → 2.99.0

package/src/lib/codex-inject.ts

@@ -0,0 +1,467 @@
+import { createHash } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getConfigDir, isLoopbackHost, type RuntimeConfig } from "../config";
+import {
+  codexHome,
+  removeManagedCodexCatalogRows,
+  resolveCodexCatalogPath,
+} from "./codex-catalog";
+
+const JOURNAL_VERSION = 1;
+const MANAGED_MARKER = "# Managed by opencodex: provider routing";
+const LOCK_STALE_MS = 30_000;
+
+export class CodexInjectionError extends Error {
+  constructor(message: string, readonly code: string) {
+    super(message);
+    this.name = "CodexInjectionError";
+  }
+}
+
+export interface CodexInjectionEndpoint {
+  host: string;
+  port: number;
+}
+
+export interface CodexInjectionResult {
+  success: boolean;
+  action: "inject" | "restore" | "restore-back";
+  changed: boolean;
+  config: { state: "ok" | "skipped" | "failed"; changed: boolean; message: string };
+  catalog: { state: "ok" | "skipped" | "failed"; changed: boolean; removed: number; message: string };
+}
+
+interface CodexJournal {
+  version: 1;
+  codexHome: string;
+  configPath: string;
+  originalConfigBase64: string | null;
+  injectedConfigHash: string;
+  catalogPath: string | null;
+  originalCatalogBase64: string | null;
+  managedCatalogHash: string | null;
+  createdAt: string;
+}
+
+interface MaybeFile {
+  exists: boolean;
+  bytes: Buffer | null;
+}
+
+function configPath(env: NodeJS.ProcessEnv): string {
+  return join(codexHome(env), "config.toml");
+}
+
+function journalPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "codex", "inject-journal.json");
+}
+
+function lockPath(env: NodeJS.ProcessEnv): string {
+  return join(getConfigDir(env), "codex", "inject.lock");
+}
+
+function hash(bytes: string | Buffer): string {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+function b64(bytes: Buffer | null): string | null {
+  return bytes ? bytes.toString("base64") : null;
+}
+
+function unb64(value: string | null): Buffer | null {
+  return value ? Buffer.from(value, "base64") : null;
+}
+
+async function readMaybe(path: string): Promise<MaybeFile> {
+  try {
+    return { exists: true, bytes: await readFile(path) };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { exists: false, bytes: null };
+    throw error;
+  }
+}
+
+async function writeAtomic(path: string, bytes: string | Buffer, mode = 0o600): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { mode, flag: "wx" });
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+    await chmod(path, mode).catch(() => undefined);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => undefined);
+  }
+}
+
+function alive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+async function withLock<T>(env: NodeJS.ProcessEnv, fn: () => Promise<T>): Promise<T> {
+  const path = lockPath(env);
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const acquire = async (): Promise<boolean> => {
+    try {
+      await writeFile(path, JSON.stringify({ pid: process.pid, at: Date.now() }), { mode: 0o600, flag: "wx" });
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+      let stale = false;
+      try {
+        const info = await stat(path);
+        let pid = 0;
+        try { pid = (JSON.parse(await readFile(path, "utf8")) as { pid?: number }).pid ?? 0; } catch { /* malformed */ }
+        stale = Date.now() - info.mtimeMs > LOCK_STALE_MS || (pid > 0 && !alive(pid));
+      } catch {
+        stale = true;
+      }
+      if (stale) {
+        await rm(path, { force: true }).catch(() => undefined);
+        return await acquire();
+      }
+      return false;
+    }
+  };
+  if (!await acquire()) throw new CodexInjectionError("Another Codex configuration change is in progress; retry after it finishes.", "codex_config_busy");
+  try {
+    return await fn();
+  } finally {
+    await rm(path, { force: true }).catch(() => undefined);
+  }
+}
+
+function isProviderHeader(line: string): boolean {
+  return /^\s*\[\s*model_providers\.opencodex(?:\s*\.|\s*\])/.test(line);
+}
+
+function isTableHeader(line: string): boolean {
+  return /^\s*\[/.test(line);
+}
+
+function rootEnd(lines: readonly string[]): number {
+  const index = lines.findIndex(isTableHeader);
+  return index < 0 ? lines.length : index;
+}
+
+function rootValue(text: string, key: string): string | undefined {
+  const lines = text.split(/\r?\n/);
+  const end = rootEnd(lines);
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m");
+  for (let index = 0; index < end; index++) {
+    const match = re.exec(lines[index]!);
+    if (match) return match[1] ?? "";
+  }
+  return undefined;
+}
+
+function setRootValue(text: string, key: string, value: string | undefined): string {
+  const lines = text.split(/\r?\n/);
+  let end = rootEnd(lines);
+  let found = false;
+  const re = new RegExp(`^\\s*${key}\\s*=`);
+  for (let index = 0; index < end; index++) {
+    if (!re.test(lines[index]!)) continue;
+    found = true;
+    if (value === undefined) {
+      lines.splice(index, 1);
+      end -= 1;
+    } else {
+      lines[index] = `${key} = ${JSON.stringify(value)}`;
+    }
+    break;
+  }
+  if (!found && value !== undefined) {
+    lines.splice(end, 0, `${key} = ${JSON.stringify(value)}`);
+    end += 1;
+  }
+  return lines.join("\n");
+}
+
+function hasUnmarkedProviderTable(text: string): boolean {
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    if (!isProviderHeader(lines[index]!)) continue;
+    let previous = index - 1;
+    while (previous >= 0 && lines[previous]!.trim() === "") previous--;
+    if (lines[previous]?.trim() !== MANAGED_MARKER) return true;
+  }
+  return false;
+}
+
+function stripProviderTables(text: string): string {
+  const lines = text.split(/\r?\n/);
+  const out: string[] = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (isTableHeader(line)) {
+      if (isProviderHeader(line)) {
+        skipping = true;
+        while (out.length > 0 && out[out.length - 1]!.trim() === MANAGED_MARKER) out.pop();
+        continue;
+      }
+      skipping = false;
+    }
+    if (skipping) continue;
+    if (line.trim() === MANAGED_MARKER) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+function providerBlock(endpoint: CodexInjectionEndpoint): string {
+  const base = `http://${endpoint.host}:${endpoint.port}/v1`;
+  return [
+    MANAGED_MARKER,
+    "[model_providers.opencodex]",
+    'name = "opencodex (Cline or Gemini CLI)"',
+    `base_url = ${JSON.stringify(base)}`,
+    'wire_api = "responses"',
+    "requires_openai_auth = false",
+    `model_catalog_url = ${JSON.stringify(`${base}/model-catalog`)}`,
+  ].join("\n");
+}
+
+function routedModel(original: string, config: RuntimeConfig): string {
+  const current = rootValue(original, "model");
+  if (current?.startsWith("cline-cli/") || current?.startsWith("gemini-cli/")) return current;
+  return `${config.defaultProvider}/${config.providers[config.defaultProvider].defaultModel}`;
+}
+
+function injectedConfig(text: string, endpoint: CodexInjectionEndpoint, config: RuntimeConfig): string {
+  if (hasUnmarkedProviderTable(text)) {
+    throw new CodexInjectionError(
+      "Codex config already defines a different [model_providers.opencodex] table; refusing to overwrite it.",
+      "codex_provider_conflict",
+    );
+  }
+  let next = stripProviderTables(text);
+  next = setRootValue(next, "model_provider", "opencodex");
+  next = setRootValue(next, "model", routedModel(text, config));
+  const body = next.trimEnd();
+  return `${body}${body ? "\n\n" : ""}${providerBlock(endpoint)}\n`;
+}
+
+function restoreRoots(current: string, original: string | null): string {
+  let next = stripProviderTables(current);
+  for (const key of ["model_provider", "model"] as const) {
+    next = setRootValue(next, key, original === null ? undefined : rootValue(original, key));
+  }
+  return next;
+}
+
+async function readJournal(env: NodeJS.ProcessEnv): Promise<CodexJournal | null> {
+  let raw: string;
+  try {
+    raw = await readFile(journalPath(env), "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  }
+  let parsed: Partial<CodexJournal>;
+  try {
+    parsed = JSON.parse(raw) as Partial<CodexJournal>;
+  } catch {
+    throw new CodexInjectionError("The Codex restore journal is malformed; it was preserved.", "codex_journal_malformed");
+  }
+  if (parsed.version !== JOURNAL_VERSION || typeof parsed.configPath !== "string" || typeof parsed.injectedConfigHash !== "string") {
+    throw new CodexInjectionError("The Codex restore journal is invalid; it was preserved.", "codex_journal_invalid");
+  }
+  return parsed as CodexJournal;
+}
+
+async function writeJournal(env: NodeJS.ProcessEnv, journal: CodexJournal): Promise<void> {
+  await writeAtomic(journalPath(env), `${JSON.stringify(journal, null, 2)}\n`);
+}
+
+function endpointError(endpoint: CodexInjectionEndpoint): void {
+  if (!Number.isInteger(endpoint.port) || endpoint.port < 1 || endpoint.port > 65_535) {
+    throw new CodexInjectionError("The Codex proxy endpoint port is invalid.", "codex_endpoint_invalid");
+  }
+  if (!isLoopbackHost(endpoint.host)) {
+    throw new CodexInjectionError("Codex injection requires a loopback proxy endpoint.", "codex_endpoint_non_loopback");
+  }
+}
+
+function validateToml(text: string): void {
+  if (!text.trim()) return;
+  try {
+    Bun.TOML.parse(text);
+  } catch {
+    throw new CodexInjectionError("Codex config is not valid TOML; it was preserved.", "codex_config_malformed");
+  }
+}
+
+/** Inject routing and persist the pre-image before touching Codex config. */
+export async function injectCodexConfig(options: {
+  env: NodeJS.ProcessEnv;
+  endpoint: CodexInjectionEndpoint;
+  config: RuntimeConfig;
+}): Promise<CodexInjectionResult> {
+  endpointError(options.endpoint);
+  return await withLock(options.env, async () => {
+    const path = configPath(options.env);
+    const current = await readMaybe(path);
+    if (current.exists) validateToml(current.bytes!.toString("utf8"));
+    const existing = await readJournal(options.env);
+    const originalConfig = existing ? unb64(existing.originalConfigBase64) : current.bytes;
+    const originalCatalog = existing ? unb64(existing.originalCatalogBase64) : null;
+    const catalogPath = existing?.catalogPath ?? await resolveCodexCatalogPath(options.env) ?? null;
+    const catalog = catalogPath ? await readMaybe(catalogPath) : { exists: false, bytes: null };
+    const before = current.bytes?.toString("utf8") ?? "";
+    if (existing && !hasManagedProvider(before)) {
+      throw new CodexInjectionError(
+        "A Codex restore journal exists but Codex routing is already native; run `ocx restore` before starting again.",
+        "codex_journal_state_conflict",
+      );
+    }
+    const next = injectedConfig(before, options.endpoint, options.config);
+    const journal: CodexJournal = {
+      version: JOURNAL_VERSION,
+      codexHome: codexHome(options.env),
+      configPath: path,
+      originalConfigBase64: b64(originalConfig),
+      injectedConfigHash: hash(next),
+      catalogPath: existing?.catalogPath ?? catalogPath,
+      originalCatalogBase64: existing ? existing.originalCatalogBase64 : b64(catalog.bytes),
+      managedCatalogHash: existing?.managedCatalogHash ?? null,
+      createdAt: existing?.createdAt ?? new Date().toISOString(),
+    };
+    await writeJournal(options.env, journal);
+    try {
+      await writeAtomic(path, next);
+    } catch (error) {
+      if (!existing) await rm(journalPath(options.env), { force: true }).catch(() => undefined);
+      throw error;
+    }
+    return {
+      success: true,
+      action: "inject",
+      changed: true,
+      config: { state: "ok", changed: true, message: "Codex routing is pointed at the local proxy." },
+      catalog: { state: "ok", changed: false, removed: 0, message: originalCatalog ? "Original catalog is journaled." : "Catalog state is journaled." },
+    };
+  });
+}
+
+function hasManagedProvider(text: string): boolean {
+  return text.includes(MANAGED_MARKER);
+}
+
+async function restoreCatalog(journal: CodexJournal): Promise<CodexInjectionResult["catalog"]> {
+  const path = journal.catalogPath;
+  if (!path) return { state: "skipped", changed: false, removed: 0, message: "No managed catalog path was journaled." };
+  const current = await readMaybe(path);
+  if (!current.exists) return { state: "skipped", changed: false, removed: 0, message: "No managed catalog file was present." };
+  const currentHash = hash(current.bytes!);
+  const original = unb64(journal.originalCatalogBase64);
+  if (journal.managedCatalogHash && currentHash === journal.managedCatalogHash) {
+    if (original === null) {
+      await rm(path, { force: true });
+      return { state: "ok", changed: true, removed: 0, message: "Removed the opencodex-owned catalog file." };
+    }
+    await writeAtomic(path, original);
+    return { state: "ok", changed: true, removed: 0, message: "Restored the original Codex catalog." };
+  }
+  try {
+    const removed = await removeManagedCodexCatalogRows(path);
+    return { state: "ok", changed: removed.changed, removed: removed.removed, message: removed.message };
+  } catch (error) {
+    return { state: "failed", changed: false, removed: 0, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/** Restore native Codex config/catalog; no-op when nothing was managed. */
+export async function restoreCodexConfig(options: {
+  env: NodeJS.ProcessEnv;
+  removeProviderTable?: boolean;
+}): Promise<CodexInjectionResult> {
+  return await withLock(options.env, async () => {
+    const journal = await readJournal(options.env);
+    const path = configPath(options.env);
+    const current = await readMaybe(path);
+    if (current.exists) validateToml(current.bytes!.toString("utf8"));
+    if (!journal) {
+      let catalog: CodexInjectionResult["catalog"] = {
+        state: "skipped", changed: false, removed: 0, message: "No journal was present.",
+      };
+      const catalogPath = await resolveCodexCatalogPath(options.env);
+      if (catalogPath) {
+        try {
+          const removed = await removeManagedCodexCatalogRows(catalogPath);
+          catalog = { state: "ok", changed: removed.changed, removed: removed.removed, message: removed.message };
+        } catch (error) {
+          catalog = { state: "failed", changed: false, removed: 0, message: error instanceof Error ? error.message : String(error) };
+        }
+      }
+      if (!current.exists) {
+        return {
+          success: catalog.state !== "failed", action: "restore", changed: catalog.changed,
+          config: { state: "skipped", changed: false, message: "Codex config was not present." },
+          catalog,
+        };
+      }
+      const text = current.bytes!.toString("utf8");
+      if (hasUnmarkedProviderTable(text) && !options.removeProviderTable) {
+        throw new CodexInjectionError("Codex contains an unmarked opencodex provider table; refusing to remove it.", "codex_provider_conflict");
+      }
+      if (!hasManagedProvider(text) && !options.removeProviderTable) {
+        return {
+          success: catalog.state !== "failed", action: "restore", changed: catalog.changed,
+          config: { state: "skipped", changed: false, message: "Codex is already using its native configuration." },
+          catalog,
+        };
+      }
+      const restored = restoreRoots(text, null);
+      await writeAtomic(path, restored);
+      return {
+        success: catalog.state !== "failed", action: "restore", changed: true || catalog.changed,
+        config: { state: "ok", changed: true, message: "Removed managed Codex routing; no pre-image journal was available." },
+        catalog,
+      };
+    }
+    const original = unb64(journal.originalConfigBase64);
+    const text = current.bytes?.toString("utf8") ?? "";
+    let changed = false;
+    let message = "Codex config was already native.";
+    if (current.exists && hash(current.bytes!) === journal.injectedConfigHash) {
+      if (original === null) await rm(path, { force: true });
+      else await writeAtomic(path, original);
+      changed = true;
+      message = original === null ? "Removed the managed Codex config." : "Restored the original Codex config.";
+    } else if (hasManagedProvider(text)) {
+      if (hasUnmarkedProviderTable(text) && !options.removeProviderTable) {
+        throw new CodexInjectionError("Codex contains an unmarked opencodex provider table; refusing to remove it.", "codex_provider_conflict");
+      }
+      await writeAtomic(path, restoreRoots(text, original?.toString("utf8") ?? null));
+      changed = true;
+      message = "Removed managed Codex routing while preserving unrelated edits.";
+    }
+    const catalog = await restoreCatalog(journal);
+    if (catalog.state === "failed") {
+      return {
+        success: false, action: "restore", changed,
+        config: { state: "ok", changed, message },
+        catalog,
+      };
+    }
+    await rm(journalPath(options.env), { force: true });
+    return {
+      success: true, action: "restore", changed: changed || catalog.changed,
+      config: { state: changed ? "ok" : "skipped", changed, message },
+      catalog,
+    };
+  });
+}
+
+/** Record the post-sync catalog hash so a later exact restore can remove it. */
+export async function recordCodexCatalogState(env: NodeJS.ProcessEnv): Promise<void> {
+  await withLock(env, async () => {
+    const journal = await readJournal(env);
+    if (!journal?.catalogPath) return;
+    const current = await readMaybe(journal.catalogPath);
+    journal.managedCatalogHash = current.exists ? hash(current.bytes!) : null;
+    await writeJournal(env, journal);
+  });
+}

package/src/server/index.ts

@@ -13,8 +13,13 @@ import type { GeminiTurnDeps } from "../adapters/cli-agent/gemini/adapter";
 import { discoverClineLiveModels } from "../adapters/cli-agent/cline/live-models";
 import { discoverGeminiLiveModels } from "../adapters/cli-agent/gemini/live-models";
 import { buildCodexCatalogDocument, discoverCodexCatalogModels } from "../lib/codex-catalog";
-import { handleResponses, modelList, RequestValidationError, UnsupportedMediaError, type ProviderModels } from "./responses";
+import { handleResponses, modelList, RequestValidationError, UnsupportedMediaError, UnsupportedOptionError, type ProviderModels } from "./responses";
 import { handleCountTokens, handleMessages } from "./messages";
+import {
+  createWebSocketHandlers,
+  type WebSocketData,
+  type WebSocketRequestObservation,
+} from "./websocket";
 
 const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 300_000;
@@ -24,6 +29,7 @@ export interface ServerOptions {
   clineDeps?: ClineTurnDeps;
   geminiDeps?: GeminiTurnDeps;
   geminiPackageRoot?: string;
+  onWebSocketRequest?: (observation: WebSocketRequestObservation) => void;
 }
 
 export interface RunningServer {
@@ -66,6 +72,9 @@ async function boundedJson(req: Request): Promise<unknown> {
 }
 
 function errorResponse(error: unknown): Response {
+  if (error instanceof UnsupportedOptionError) {
+    return Response.json({ error: { message: error.message, type: error.type, code: error.code } }, { status: error.status });
+  }
   if (error instanceof UnsupportedMediaError) {
     return Response.json({ error: { message: error.message, type: error.type, code: error.code } }, { status: error.status });
   }
@@ -114,7 +123,7 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
   const token = apiToken(config, env);
   let server: ReturnType<typeof Bun.serve>;
 
-  const fetch = async (req: Request): Promise<Response> => {
+  const fetch = async (req: Request, bunServer: Bun.Server<WebSocketData>): Promise<Response | undefined> => {
     const url = new URL(req.url);
     if (url.pathname === "/healthz") {
       return Response.json({ ok: true, service: "opencodex", version: packageInfo.version });
@@ -122,6 +131,11 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     if (!authorized(req, token)) {
       return Response.json({ error: { message: "Unauthorized", type: "authentication_error", code: "unauthorized" } }, { status: 401 });
     }
+    if (req.method === "GET" && url.pathname === "/v1/responses" && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+      const data: WebSocketData = { headers: req.headers, queue: Promise.resolve(), closed: false };
+      if (bunServer.upgrade(req, { data })) return undefined;
+      return new Response("WebSocket upgrade failed.", { status: 400 });
+    }
     try {
       if (req.method === "GET" && url.pathname === "/v1/models") {
         const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
@@ -158,7 +172,20 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     }
   };
 
-  server = Bun.serve({ hostname: config.host, port: config.port, idleTimeout: 255, fetch });
+  const websocketContext = {
+    knownModels: () => discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot),
+    deps: turnDeps,
+    defaultProvider: config.defaultProvider,
+    timeoutMs: REQUEST_TIMEOUT_MS,
+    ...(options.onWebSocketRequest ? { onRequest: options.onWebSocketRequest } : {}),
+  };
+  server = Bun.serve({
+    hostname: config.host,
+    port: config.port,
+    idleTimeout: 255,
+    fetch,
+    websocket: createWebSocketHandlers(websocketContext),
+  });
   return {
     port: server.port ?? config.port,
     host: config.host,