@jaralabs/codex-bridge 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Jaramillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,99 @@
-# Temporary Holding Version
+# @jaralabs/codex-bridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Use your ChatGPT Business / Team / Plus subscription from OpenCode instead of paying for the OpenAI API.
+
+`codex-bridge` runs an OpenAI-compatible HTTP server on `127.0.0.1:11434` that
+forwards chat-completion requests to the [OpenAI Codex CLI][codex]. Because
+the Codex CLI reuses the local ChatGPT OAuth session in `~/.codex/auth.json`,
+your OpenCode prompts consume your subscription credits — not the OpenAI API
+balance.
+
+[codex]: https://github.com/openai/codex
+
+## Why
+
+If you have a ChatGPT Business / Team / Plus plan, the OpenAI API and the
+ChatGPT web subscription are billed separately. You can use Codex CLI / web
+App today with the subscription. `codex-bridge` exposes the same models over
+an OpenAI-compatible HTTP surface so OpenCode (and any other OpenAI client
+like Claude Code, Cline, aider) can use them without an API key.
+
+## Install
+
+```bash
+npm install -g @jaralabs/codex-bridge
+```
+
+Requires Node 18 or newer and the OpenAI Codex CLI installed and logged in
+once with `codex login` on a machine with the ChatGPT Business / Team / Plus
+session.
+
+## Wire it into OpenCode
+
+Add a `chatgpt` provider to `~/.config/opencode/opencode.jsonc`:
+
+```json
+{
+  "provider": {
+    "chatgpt": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "ChatGPT Business (codex-bridge)",
+      "options": {
+        "baseURL": "http://127.0.0.1:11434/v1"
+      },
+      "models": {
+        "gpt-6.1-sol": {
+          "name": "GPT-6.1 Sol (Business)",
+          "limit": { "context": 272000, "output": 128000 },
+          "modalities": { "input": ["text", "image"], "output": ["text"] }
+        }
+      }
+    }
+  }
+}
+```
+
+The exact model list depends on what your plan exposes. `codex-bridge start`
+syncs the model list from `~/.codex/models_cache.json` (refreshed by Codex
+whenever it talks to ChatGPT) and rewrites the `provider.chatgpt.models`
+block to match. Re-run `codex-bridge start` after any plan change.
+
+## Usage
+
+```bash
+codex-bridge start    # sync models + start HTTP server in background
+codex-bridge status   # is it up?
+codex-bridge sync     # only sync model list (no server)
+codex-bridge logs     # tail the server log
+codex-bridge stop     # kill the server
+```
+
+In another terminal:
+
+```bash
+opencode run --model=chatgpt/gpt-6.1-sol "say hi"
+```
+
+## How it works
+
+```
+┌──────────┐        HTTP (OpenAI-compatible)        ┌────────────────┐
+│ OpenCode │ ──────────────────────────────────────▶ │ codex-bridge   │
+│          │ ◀────────────────────────────────────── │ 127.0.0.1:11434│
+└──────────┘                                         └────────────────┘
+                                                          │
+                                       spawns             ▼
+                                                  ┌─────────────────┐
+                                                  │ codex exec      │
+                                                  │ (uses ChatGPT   │
+                                                  │  OAuth session) │
+                                                  └─────────────────┘
+```
+
+The bridge has zero state of its own. It just maps an OpenAI-style HTTP
+request into a Codex CLI invocation and pipes the result back. Codex handles
+auth, plan routing, and rate limits.
+
+## License
+
+MIT.

package/bin/codex-bridge

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// codex-bridge CLI: entry point for `codex-bridge start|stop|status|sync|logs`.
+// Resolves the package root via npm CLI conventions so paths work whether the
+// package is installed globally, locally, or run from a checkout.
+
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  createWriteStream,
+  unlinkSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = dirname(__dirname);
+
+const PORT = process.env.PORT || "11434";
+const HOST = process.env.HOST || "127.0.0.1";
+const PID_FILE = process.env.CODEX_BRIDGE_PID || "/tmp/codex-bridge.pid";
+const LOG_FILE = process.env.CODEX_BRIDGE_LOG || "/tmp/codex-bridge.log";
+
+function log(level, msg, extra) {
+  const line = JSON.stringify({
+    t: new Date().toISOString(),
+    src: "codex-bridge",
+    level,
+    msg,
+    ...(extra || {}),
+  });
+  process.stderr.write(line + "\n");
+}
+
+function readAuth() {
+  // Sanity-check that codex is logged in. We don't use the tokens
+  // directly — `codex exec` does — but we want to fail fast with a
+  // helpful message if the user hasn't run `codex login`.
+  const home = process.env.HOME || "/tmp";
+  const authPath = join(home, ".codex", "auth.json");
+  if (!existsSync(authPath)) return null;
+  try {
+    return JSON.parse(readFileSync(authPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function runSync() {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [join(PKG_ROOT, "lib", "sync-cache.mjs")], {
+      stdio: "inherit",
+      env: { ...process.env, CODEX_HOME: process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex") },
+    });
+    child.on("close", (code) => resolve(code ?? 0));
+  });
+}
+
+async function startServer() {
+  if (existsSync(PID_FILE)) {
+    const pid = parseInt(readFileSync(PID_FILE, "utf8").trim(), 10);
+    try {
+      process.kill(pid, 0);
+      log("info", "already running", { pid, port: PORT });
+      process.stdout.write(`codex-bridge already running (pid ${pid}) on http://${HOST}:${PORT}\n`);
+      return 0;
+    } catch {
+      // Stale PID file; proceed to start.
+    }
+  }
+
+  const auth = readAuth();
+  if (!auth || auth.auth_mode !== "chatgpt") {
+    process.stderr.write("⚠️  No ChatGPT session found at ~/.codex/auth.json.\n");
+    process.stderr.write("   Run 'codex login' once before starting codex-bridge.\n");
+    return 1;
+  }
+  if (!auth.tokens?.access_token) {
+    process.stderr.write("⚠️  auth.json has no access_token. Re-run 'codex login'.\n");
+    return 1;
+  }
+
+  await runSync();
+
+  const out = process.stdout;
+  const err = process.stderr;
+  const logStream = createWriteStream(LOG_FILE, { flags: "a" });
+  const child = spawn(process.execPath, [join(PKG_ROOT, "lib", "server.mjs")], {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      CODEX_HOME: process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex"),
+      PORT,
+      HOST,
+    },
+  });
+  child.stdout.pipe(logStream);
+  child.stderr.pipe(logStream);
+  // Also surface stderr to the controlling terminal for the first ~1s so the
+  // user sees the "listening" banner immediately, then silence stdout.
+  child.stderr.pipe(err, { end: false });
+  writeFileSync(PID_FILE, String(child.pid));
+
+  // Wait for the bridge to come up (or fail).
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    try {
+      const r = await fetch(`http://${HOST}:${PORT}/v1/models`);
+      if (r.ok) {
+        out.write(`codex-bridge up on http://${HOST}:${PORT} (pid ${child.pid})\n`);
+        // Now disown: closing stdout/stderr handles would kill the child.
+        child.stdout.unpipe();
+        child.stderr.unpipe(err);
+        child.stdout.unpipe(logStream);
+        child.stderr.unpipe(logStream);
+        child.stdout.on("data", () => {});
+        child.stderr.on("data", () => {});
+        return 0;
+      }
+    } catch {}
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return 1;
+}
+
+function stopServer() {
+  if (!existsSync(PID_FILE)) {
+    process.stdout.write("codex-bridge not running\n");
+    return 0;
+  }
+  const pid = parseInt(readFileSync(PID_FILE, "utf8").trim(), 10);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {}
+  // Give it a moment, then SIGKILL.
+  setTimeout(() => {
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }, 300);
+  try { unlinkSync(PID_FILE); } catch {}
+  process.stdout.write(`codex-bridge stopped (pid ${pid})\n`);
+  return 0;
+}
+
+function statusServer() {
+  if (!existsSync(PID_FILE)) {
+    process.stdout.write("codex-bridge stopped\n");
+    return 1;
+  }
+  const pid = parseInt(readFileSync(PID_FILE, "utf8").trim(), 10);
+  try {
+    process.kill(pid, 0);
+    process.stdout.write(`codex-bridge running (pid ${pid}) on http://${HOST}:${PORT}\n`);
+    return 0;
+  } catch {
+    process.stdout.write("codex-bridge stopped (stale pid file)\n");
+    return 1;
+  }
+}
+
+async function tailLogs() {
+  const tail = spawn("tail", ["-n", "100", "-f", LOG_FILE], { stdio: "inherit" });
+  await new Promise((resolve) => {
+    tail.on("exit", resolve);
+    process.on("SIGINT", () => tail.kill("SIGTERM"));
+  });
+}
+
+const [, , cmd] = process.argv;
+
+switch (cmd) {
+  case "start":
+    process.exit(await startServer());
+  case "stop":
+    process.exit(stopServer());
+  case "status":
+    process.exit(statusServer());
+  case "sync": {
+    const code = await runSync();
+    process.exit(code);
+  }
+  case "logs":
+    await tailLogs();
+    process.exit(0);
+  default: {
+    process.stderr.write("usage: codex-bridge {start|stop|status|sync|logs}\n");
+    process.exit(2);
+  }
+}

package/lib/plugin.ts

@@ -0,0 +1,95 @@
+// codex-bridge OpenCode plugin template.
+//
+// Install: copy this file to ~/.config/opencode/plugins/codex-bridge-models.ts
+//   or run `codex-bridge install-plugin` (TODO).
+//
+// Why a plugin: opencode 2.x doesn't hot-reload provider models when opencode.jsonc
+// changes on disk for short-lived CLI invocations like `opencode run`. In a
+// long-lived TUI server, opencode does reload, and the plugin on `session.created`
+// is purely belt-and-suspenders.
+//
+// The plugin reads ~/.codex/models_cache.json and writes the resulting model list
+// into cfg.provider.chatgpt.models. On TUI restart the change will already be
+// present in opencode.jsonc thanks to lib/sync-cache.mjs running from
+// `codex-bridge start`, so this hook is mostly a no-op.
+
+import { spawnSync } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+const CODEX_HOME = process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex")
+const CACHE = join(CODEX_HOME, "models_cache.json")
+const PROVIDER_ID = "chatgpt"
+
+const VISIBLE = new Set(["list", "default", null, undefined])
+
+function readCache(): string[] {
+  if (!existsSync(CACHE)) return []
+  try {
+    const cache = JSON.parse(readFileSync(CACHE, "utf8"))
+    if (!Array.isArray(cache.models)) return []
+    return cache.models
+      .filter((m: any) => VISIBLE.has(m.visibility ?? null))
+      .filter((m: any) => m.supported_in_api !== false)
+      .map((m: any) => m.slug)
+      .filter((s: unknown): s is string => typeof s === "string" && s.length > 0)
+      .sort()
+  } catch {
+    return []
+  }
+}
+
+function buildModels(slugs: string[]): Record<string, any> {
+  const out: Record<string, any> = {}
+  for (const slug of slugs) {
+    out[slug] = {
+      name: `${slug} (Business)`,
+      limit: { context: 272000, output: 128000 },
+      modalities: { input: ["text", "image"], output: ["text"] },
+    }
+  }
+  return out
+}
+
+function mergeModels(provider: any, slugs: string[]): void {
+  if (!provider) return
+  const desired = buildModels(slugs)
+  const current = (provider.models ?? {}) as Record<string, unknown>
+  let same = Object.keys(current).length === slugs.length
+  if (same) {
+    const curSet = new Set(Object.keys(current))
+    for (const s of slugs) if (!curSet.has(s)) { same = false; break }
+  }
+  if (!same) provider.models = desired
+}
+
+const CodexBridgeModelsPlugin = {
+  id: "codex-bridge-models",
+  async setup(_ctx: unknown) {
+    return {
+      config: async (cfg: any) => {
+        const slugs = readCache()
+        if (slugs.length === 0) return
+        if (!cfg.provider) cfg.provider = {}
+        if (!cfg.provider[PROVIDER_ID]) {
+          cfg.provider[PROVIDER_ID] = {
+            npm: "@ai-sdk/openai-compatible",
+            name: "ChatGPT Business (codex-bridge)",
+            options: { baseURL: "http://127.0.0.1:11434/v1" },
+            models: {},
+          }
+        }
+        mergeModels(cfg.provider[PROVIDER_ID], slugs)
+      },
+      event: async ({ event }: { event: { type?: string } }) => {
+        if (event?.type === "session.created") {
+          // Optional: re-sync at session start. The on-disk JSON file is already
+          // kept up to date by lib/sync-cache.mjs when codex-bridge start runs.
+        }
+      },
+    }
+  },
+}
+
+export default CodexBridgeModelsPlugin
+export { CodexBridgeModelsPlugin }

package/lib/server.mjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+// codex-bridge: OpenAI-compatible HTTP server that reuses a local ChatGPT
+// Business/Team/Plus session by shelling out to `codex exec --json`.
+// Default port: 11434. Endpoints:
+//   GET  /v1/models            -> { object:"list", data:[...] }
+//   POST /v1/chat/completions  -> OpenAI-style streaming or JSON response
+//
+// Auth: reads ~/.codex/auth.json (refreshes access_token via OpenAI's
+// refresh_token grant when expired). The token is only used so the
+// shell session stays authenticated; codex CLI handles the actual call.
+
+import http from "node:http";
+import { spawn } from "node:child_process";
+import { readFileSync, existsSync, statSync, readdirSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import { join, dirname } from "node:path";
+
+const PORT = Number(process.env.PORT || 11434);
+const HOST = process.env.HOST || "127.0.0.1";
+const CODEX_HOME =
+  process.env.CODEX_HOME || join(homedir(), ".codex");
+const AUTH_PATH = join(CODEX_HOME, "auth.json");
+const MODELS_CACHE = join(CODEX_HOME, "models_cache.json");
+
+const codexBin = (() => {
+  const fromEnv = process.env.CODEX_BIN;
+  if (fromEnv) return fromEnv;
+  try {
+    const which = spawn("which", ["codex"], { stdio: ["ignore", "pipe", "ignore"] });
+    const out = [];
+    which.stdout.on("data", (c) => out.push(c));
+    which.on("close", () => process.stdout.write(""));
+    // Note: ignored; we instead use the env-default path lookup below.
+  } catch {}
+  return "codex";
+})();
+
+// ---- Logging (minimal JSONL to stderr) ----
+function log(level, msg, extra) {
+  const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...extra });
+  process.stderr.write(line + "\n");
+}
+
+// ---- Auth handling ----
+let authCache = null;
+function loadAuth() {
+  if (!existsSync(AUTH_PATH)) {
+    throw new Error(`codex-bridge: no auth.json at ${AUTH_PATH}. Run 'codex login' first.`);
+  }
+  const raw = JSON.parse(readFileSync(AUTH_PATH, "utf8"));
+  if (raw.auth_mode !== "chatgpt") {
+    throw new Error(`codex-bridge: auth mode is '${raw.auth_mode}', need 'chatgpt'.`);
+  }
+  if (!raw.tokens?.access_token) throw new Error("codex-bridge: missing tokens.");
+  return raw;
+}
+function getAuth() {
+  if (!authCache) authCache = loadAuth();
+  return authCache;
+}
+// Token refresh is delegated to codex itself; we just rely on the CLI.
+
+// ---- Models listing ----
+function listModels() {
+  const slugId = (s) => ({
+    id: s,
+    object: "model",
+    created: 0,
+    owned_by: "openai-chatgpt",
+  });
+  let slugs = [];
+  if (existsSync(MODELS_CACHE)) {
+    try {
+      const cache = JSON.parse(readFileSync(MODELS_CACHE, "utf8"));
+      if (Array.isArray(cache.models)) {
+        slugs = cache.models
+          .filter((m) => m.visibility === "list" || m.visibility == null)
+          .map((m) => m.slug)
+          .filter(Boolean);
+      }
+    } catch (e) {
+      log("warn", "models_cache.json parse failed", { err: String(e) });
+    }
+  }
+  if (slugs.length === 0) {
+    slugs = ["gpt-6.1-sol", "gpt-6-sol", "gpt-6-luna", "gpt-6-astra"];
+  }
+  return { object: "list", data: slugs.map(slugId) };
+}
+
+// ---- codex exec runner ----
+function runCodex({ model, prompt, signal }) {
+  return new Promise((resolve, reject) => {
+    // Ensure auth is fresh enough for codex exec by reading the file (codex
+    // itself will refresh via its internal logic on the next call).
+    getAuth();
+    const args = [
+      "exec",
+      "--json",
+      "--skip-git-repo-check",
+      "-m", model,
+      prompt,
+    ];
+    const child = spawn(codexBin, args, {
+      env: {
+        ...process.env,
+        CODEX_HOME,
+        NO_COLOR: "1",
+        TERM: "dumb",
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let aborted = false;
+    const onAbort = () => {
+      aborted = true;
+      try { child.kill("SIGTERM"); } catch {}
+    };
+    if (signal) signal.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (c) => (stdout += c.toString()));
+    child.stderr.on("data", (c) => (stderr += c.toString()));
+    child.on("error", (e) => reject(e));
+    child.on("close", (code) => {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      if (aborted) return reject(new Error("aborted"));
+      if (code !== 0) {
+        return reject(
+          new Error(`codex exec exited ${code}: ${stderr.slice(0, 400)}`),
+        );
+      }
+      // Parse the last item.completed agent_message + usage.
+      let lastText = "";
+      let usage = null;
+      for (const line of stdout.split("\n")) {
+        const l = line.trim();
+        if (!l.startsWith("{")) continue;
+        let evt;
+        try { evt = JSON.parse(l); } catch { continue; }
+        if (evt.type === "item.completed" && evt.item?.type === "agent_message") {
+          lastText = evt.item.text ?? lastText;
+        }
+        if (evt.type === "turn.completed") {
+          usage = evt.usage ?? null;
+        }
+      }
+      resolve({ text: lastText, usage, stderr });
+    });
+  });
+}
+
+// ---- OpenAI shape helpers ----
+function now() { return Math.floor(Date.now() / 1000); }
+function genId(prefix) {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function toUsage(u) {
+  if (!u) return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+  const input = u.input_tokens ?? 0;
+  const output = u.output_tokens ?? 0;
+  return {
+    prompt_tokens: input,
+    completion_tokens: output,
+    total_tokens: input + output,
+  };
+}
+function renderTemplate(tmpl, vars) {
+  if (typeof tmpl === "string") return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
+  // Multimodal array: replace text parts with {{key}} expansion.
+  return tmpl
+    .map((part) =>
+      part?.type === "text"
+        ? { ...part, text: part.text.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "") }
+        : part,
+    );
+}
+
+// ---- HTTP server ----
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url || "/", `http://${req.headers.host}`);
+  try {
+    if (req.method === "GET" && url.pathname === "/healthz") {
+      return json(res, 200, { ok: true, port: PORT });
+    }
+    if (req.method === "GET" && url.pathname === "/v1/models") {
+      return json(res, 200, listModels());
+    }
+    if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+      const body = await readBody(req);
+      let payload;
+      try { payload = JSON.parse(body); } catch { return json(res, 400, { error: { message: "invalid JSON" } }); }
+      return handleChatCompletions(payload, req, res);
+    }
+    return json(res, 404, { error: { message: "not found", path: url.pathname } });
+  } catch (e) {
+    log("error", "handler failed", { err: String(e), stack: e?.stack });
+    return json(res, 500, { error: { message: String(e.message || e) } });
+  }
+});
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function json(res, status, obj) {
+  const body = JSON.stringify(obj);
+  res.writeHead(status, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(body),
+    "access-control-allow-origin": "*",
+  });
+  res.end(body);
+}
+function startSse(res, status = 200) {
+  res.writeHead(status, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache",
+    "connection": "keep-alive",
+    "x-accel-buffering": "no",
+    "access-control-allow-origin": "*",
+  });
+}
+function sse(res, event, data) {
+  if (event) res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+async function handleChatCompletions(payload, req, res) {
+  const {
+    model,
+    messages = [],
+    stream = false,
+    temperature,
+    top_p,
+    max_tokens,
+  } = payload || {};
+  if (!model) return json(res, 400, { error: { message: "model is required" } });
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return json(res, 400, { error: { message: "messages[] required" } });
+  }
+
+  // Build prompt: concatenate system/user/assistant turns.
+  const parts = [];
+  let lastRole = null;
+  for (const m of messages) {
+    if (!m || !m.role) continue;
+    let text = "";
+    if (typeof m.content === "string") text = m.content;
+    else if (Array.isArray(m.content)) {
+      text = m.content
+        .filter((p) => p?.type === "text")
+        .map((p) => p.text || "")
+        .join("\n");
+    } else if (m.content) text = String(m.content);
+    if (!text && m.role !== lastRole) parts.push("");
+    if (text) {
+      const tag = m.role.toUpperCase();
+      parts.push(`${tag}: ${text}`);
+    }
+    lastRole = m.role;
+  }
+  parts.push("ASSISTANT:");
+  const prompt = parts.filter(Boolean).join("\n\n");
+
+  const ac = new AbortController();
+  req.on("close", () => ac.abort());
+
+  log("info", "chat.completions", { model, stream, msgs: messages.length });
+  let result;
+  try {
+    result = await runCodex({ model, prompt, signal: ac.signal });
+  } catch (e) {
+    return json(res, 502, { error: { message: String(e.message || e), type: "codex_error" } });
+  }
+
+  const id = genId("chatcmpl");
+  const created = now();
+  const usage = toUsage(result.usage);
+
+  if (stream) {
+    startSse(res);
+    // First chunk: role.
+    sse(res, null, {
+      id, object: "chat.completion.chunk", created,
+      model, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+    });
+    // Content chunk (codex exec doesn't stream per-token; emit as one).
+    if (result.text) {
+      sse(res, null, {
+        id, object: "chat.completion.chunk", created,
+        model,
+        choices: [{
+          index: 0,
+          delta: { content: result.text },
+          finish_reason: null,
+        }],
+      });
+    }
+    // Final chunk with finish_reason + usage.
+    sse(res, null, {
+      id, object: "chat.completion.chunk", created, model,
+      choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+    });
+    sse(res, null, {
+      id, object: "chat.completion.chunk", created, model,
+      choices: [],
+      usage,
+    });
+    res.write("data: [DONE]\n\n");
+    res.end();
+    return;
+  }
+
+  return json(res, 200, {
+    id, object: "chat.completion", created, model,
+    choices: [{
+      index: 0,
+      message: { role: "assistant", content: result.text },
+      finish_reason: "stop",
+      logprobs: null,
+    }],
+    usage,
+  });
+}
+
+server.listen(PORT, HOST, () => {
+  log("info", "listening", { url: `http://${HOST}:${PORT}`, codex_home: CODEX_HOME });
+});
+
+process.on("SIGTERM", () => server.close(() => process.exit(0)));
+process.on("SIGINT", () => server.close(() => process.exit(0)));

package/lib/sync-cache.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+// sync-cache.mjs: merge the codex models cache into opencode.jsonc so the
+// `provider.chatgpt.models` block stays in sync with the user's ChatGPT
+// plan. Idempotent: prints "unchanged" if the file wouldn't change.
+//
+// Usage:
+//   node sync-cache.mjs [--config <path>] [--codex-home <path>] [--provider <name>] [--write|--no-write]
+//
+// Default config:   ~/.config/opencode/opencode.jsonc
+// Default codex home: ~/.codex
+// Default provider name: chatgpt
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const args = process.argv.slice(2);
+function flag(name, fallback) {
+  const i = args.indexOf(`--${name}`);
+  if (i >= 0 && i + 1 < args.length) return args[i + 1];
+  return fallback;
+}
+function hasFlag(name) { return args.includes(`--${name}`); }
+
+const CONFIG_PATH = flag("config", join(homedir(), ".config", "opencode", "opencode.jsonc"));
+const CODEX_HOME = flag("codex-home", join(homedir(), ".codex"));
+const PROVIDER = flag("provider", "chatgpt");
+const DO_WRITE = !hasFlag("no-write");
+const CACHE_PATH = join(CODEX_HOME, "models_cache.json");
+
+// ---- 1. Load models from codex cache ----
+if (!existsSync(CACHE_PATH)) {
+  console.error(`sync-cache: no models_cache.json at ${CACHE_PATH}`);
+  process.exit(0); // not an error: codex hasn't been run yet
+}
+
+const cache = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+if (!Array.isArray(cache.models)) {
+  console.error("sync-cache: cache.models is not an array");
+  process.exit(0);
+}
+
+// Visibility gate: include models that are list-able. Some are hidden / review-only.
+const VISIBLE = ["list", "default", null, undefined];
+const slugs = cache.models
+  .filter((m) => VISIBLE.includes(m.visibility))
+  .filter((m) => m.supported_in_api !== false) // skip codex-auto-review etc.
+  .map((m) => m.slug)
+  .filter(Boolean);
+
+// Stable order: priority first, then slug.
+slugs.sort((a, b) => {
+  const ma = cache.models.find((x) => x.slug === a) || {};
+  const mb = cache.models.find((x) => x.slug === b) || {};
+  return (ma.priority ?? 999) - (mb.priority ?? 999) || a.localeCompare(b);
+});
+
+if (slugs.length === 0) {
+  console.error("sync-cache: no usable slugs in cache");
+  process.exit(0);
+}
+
+// ---- 2. Build the desired models block ----
+const desired = {};
+for (const slug of slugs) {
+  desired[slug] = {
+    name: `${slug} (Business)`,
+    limit: { context: 272000, output: 128000 },
+    modalities: { input: ["text", "image"], output: ["text"] },
+  };
+}
+
+// ---- 3. Compare with current file ----
+if (!existsSync(CONFIG_PATH)) {
+  console.error(`sync-cache: no config at ${CONFIG_PATH}`);
+  process.exit(1);
+}
+const raw = readFileSync(CONFIG_PATH, "utf8");
+
+// Detect JSONC by stripping comments + trailing commas before JSON.parse.
+// We don't rewrite the file as JSON; we only do textual surgery for the
+// provider.<name>.models block. Keeps comments and surrounding formatting.
+function stripJsonc(src) {
+  let out = "";
+  let i = 0;
+  let inStr = false;
+  let quote = "";
+  while (i < src.length) {
+    const c = src[i];
+    if (inStr) {
+      out += c;
+      if (c === "\\" && i + 1 < src.length) { out += src[i + 1]; i += 2; continue; }
+      if (c === quote) inStr = false;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") { inStr = true; quote = c; out += c; i++; continue; }
+    if (c === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out.replace(/,\s*([}\]])/g, "$1");
+}
+
+const pure = stripJsonc(raw);
+const cfg = JSON.parse(pure);
+
+const current = cfg.provider?.[PROVIDER] || null;
+const currentModels = current?.models || {};
+const currentSlugs = Object.keys(currentModels);
+
+function sameSet(a, b) {
+  if (a.length !== b.length) return false;
+  const sb = new Set(b);
+  for (const x of a) if (!sb.has(x)) return false;
+  return true;
+}
+
+if (sameSet(currentSlugs, slugs)) {
+  console.log(JSON.stringify({ status: "unchanged", count: slugs.length, path: CONFIG_PATH }));
+  process.exit(0);
+}
+
+// ---- 4. Rewrite only the provider block in the file ----
+// We rebuild the file by:
+//   - re-serializing a minimal copy
+//   - splicing the new block back into the original JSONC at the exact
+//     position of `provider.chatgpt.models`
+// Easier alternative: keep everything else verbatim and replace the models
+// block via a regex-friendly region. We do it by:
+//   1. compute the slice boundaries of `provider.chatgpt` in the JSONC
+//   2. replace it with the rebuilt block
+//
+// For safety with the formatting quirks of JSONC we always preserve the
+// indent style of the existing file by sampling indentation from the line
+// containing `provider`.
+
+function detectIndent(src) {
+  const m = src.match(/^[ \t]+(?=[^\s])/m);
+  if (!m) return "  ";
+  const prefix = m[0];
+  if (prefix.includes("\t")) return "\t";
+  return " ".repeat(prefix.length);
+}
+const indent = detectIndent(raw);
+
+function renderModelsBlock(models, baseIndent) {
+  const lines = ["{"];
+  const keys = Object.keys(models);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    const m = models[k];
+    const last = i === keys.length - 1;
+    lines.push(`${baseIndent}"${k}": {`);
+    lines.push(`${baseIndent}  "name": ${JSON.stringify(m.name)},`);
+    lines.push(`${baseIndent}  "limit": { "context": ${m.limit.context}, "output": ${m.limit.output} },`);
+    lines.push(`${baseIndent}  "modalities": { "input": ${JSON.stringify(m.modalities.input)}, "output": ${JSON.stringify(m.modalities.output)} }`);
+    lines.push(`${baseIndent}}${last ? "" : ","}`);
+  }
+  lines.push(`${baseIndent.slice(0, baseIndent.length - (baseIndent.length > 2 ? 2 : baseIndent.length))}}`);
+  return lines.join("\n");
+}
+
+function replaceProvider(rawText, providerName, newProviderObj) {
+  // Find the provider's key at whatever indent level it's at.
+  // We capture the leading indent so the replacement is inserted with the
+  // matching outer indent. Inner indents are derived as outerIndent + step.
+  const re = new RegExp(`(^|\\n)([ \\t]*)"${providerName}"\\s*:\\s*\\{`);
+  const m = re.exec(rawText);
+  if (!m) return null;
+  const outerIndent = m[2];
+  const step = "  "; // assume 2-space step; sample below if we find better evidence
+
+  // Walk braces from the opening `{` of this provider object.
+  const startBrace = m.index + m[0].length - 1; // points to '{'
+  let depth = 0;
+  let i = startBrace;
+  let inStr = false, quote = "";
+  while (i < rawText.length) {
+    const c = rawText[i];
+    if (inStr) {
+      if (c === "\\") { i += 2; continue; }
+      if (c === quote) inStr = false;
+      i++; continue;
+    }
+    if (c === '"' || c === "'") { inStr = true; quote = c; i++; continue; }
+    // skip line comments loosely (we don't try to be perfect here, JSONC comments
+    // inside strings are rare and we only insert at this exact scope).
+    if (c === "/" && rawText[i + 1] === "/") {
+      while (i < rawText.length && rawText[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") { depth--; if (depth === 0) { i++; break; } }
+    i++;
+  }
+  const endBrace = i - 1;
+  // Now we own rawText.slice(startBrace, i) — the provider object body.
+
+  // Build a fresh provider object that preserves baseURL/options but replaces models.
+  const preserved = { ...newProviderObj };
+  preserved.models = newProviderObj.models;
+
+  // Render the new provider block with stable JSON (no comments inside)
+  // using indent sized as outerIndent + step. We rebuild with a custom dumper
+  // so each line carries the correct prefix.
+  function dump(obj, prefix) {
+    const lines = [];
+    const innerPrefix = prefix + step;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    lines.push("{");
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const v = obj[k];
+      const last = i === keys.length - 1;
+      const comma = last ? "" : ",";
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        lines.push(`${innerPrefix}${JSON.stringify(k)}: ${dump(v, innerPrefix)}${comma}`);
+      } else {
+        lines.push(`${innerPrefix}${JSON.stringify(k)}: ${JSON.stringify(v)}${comma}`);
+      }
+    }
+    lines.push(`${prefix}}`);
+    return lines.join("\n");
+  }
+  const replacement = dump(preserved, outerIndent);
+
+  // Make it match the file's line endings style by normalizing.
+  const fileLE = rawText.includes("\r\n") ? "\r\n" : "\n";
+  const replacementLE = replacement.replace(/\n/g, fileLE);
+
+  return rawText.slice(0, startBrace) + replacementLE + rawText.slice(endBrace + 1);
+}
+
+const nextCfg = JSON.parse(JSON.stringify(cfg));
+if (!nextCfg.provider) nextCfg.provider = {};
+if (!nextCfg.provider[PROVIDER]) nextCfg.provider[PROVIDER] = {};
+nextCfg.provider[PROVIDER].models = desired;
+
+// Touch `.options` only if missing — don't overwrite user config.
+if (cfg.provider?.[PROVIDER]?.options?.baseURL) {
+  nextCfg.provider[PROVIDER].options = cfg.provider[PROVIDER].options;
+}
+
+const newRaw = replaceProvider(raw, PROVIDER, nextCfg.provider[PROVIDER]);
+if (newRaw == null) {
+  console.error(`sync-cache: provider '${PROVIDER}' not found in config`);
+  process.exit(1);
+}
+
+// Validate the new file as JSONC-roundtrip.
+try {
+  JSON.parse(stripJsonc(newRaw));
+} catch (e) {
+  console.error("sync-cache: generated file is invalid JSONC:", e.message);
+  process.exit(2);
+}
+
+if (!DO_WRITE) {
+  console.log(JSON.stringify({ status: "dry-run", added: slugs.length, removed: currentSlugs.length }));
+  process.exit(0);
+}
+
+writeFileSync(CONFIG_PATH, newRaw, "utf8");
+console.log(JSON.stringify({
+  status: "written",
+  path: CONFIG_PATH,
+  before: currentSlugs.length,
+  after: slugs.length,
+  added: slugs.filter((s) => !currentSlugs.includes(s)),
+  removed: currentSlugs.filter((s) => !slugs.includes(s)),
+}));

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@jaralabs/codex-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "private": false,
+  "description": "OpenAI-compatible HTTP bridge that reuses a local ChatGPT Business / Team / Plus session via codex, so OpenCode can list and call those models without paying for the OpenAI API.",
+  "type": "module",
+  "main": "lib/server.mjs",
+  "exports": {
+    ".": "./lib/server.mjs",
+    "./sync": "./lib/sync-cache.mjs",
+    "./plugin": "./lib/plugin.ts"
+  },
+  "bin": {
+    "codex-bridge": "bin/codex-bridge"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "start": "bin/codex-bridge start",
+    "stop": "bin/codex-bridge stop",
+    "status": "bin/codex-bridge status",
+    "sync": "bin/codex-bridge sync",
+    "logs": "bin/codex-bridge logs",
+    "test": "node test/test.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaralabs/codex-bridge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jaralabs/codex-bridge/issues"
+  },
+  "keywords": [
+    "opencode",
+    "chatgpt",
+    "codex",
+    "openai-compatible",
+    "bridge",
+    "subscription",
+    "coding-agent"
+  ],
+  "author": "Andrew Jaramillo <javamillog1999@outlook.com>",
+  "license": "MIT"
+}