@jaralabs/codex-bridge 0.1.0 → 0.2.0

package/bin/codex-bridge

@@ -88,19 +88,22 @@ async function startServer() {
   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"],
+    // detached + unref so the server outlives the bin and survives the bin
+    // exiting. We redirect stdout/stderr to /dev/null — the server ignores
+    // SIGPIPE, but the simpler fix is to not have parent-owned pipes at all.
+    // Logs go through LOG_FILE written by the server itself, not via stream
+    // piping.
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
     env: {
       ...process.env,
       CODEX_HOME: process.env.CODEX_HOME || join(process.env.HOME || "/tmp", ".codex"),
       PORT,
       HOST,
+      CODEX_BRIDGE_LOG: LOG_FILE,
     },
   });
-  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 });
+  child.unref();
   writeFileSync(PID_FILE, String(child.pid));
 
   // Wait for the bridge to come up (or fail).
@@ -110,13 +113,6 @@ async function startServer() {
       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 {}

package/lib/server.mjs

@@ -35,12 +35,24 @@ const codexBin = (() => {
   return "codex";
 })();
 
-// ---- Logging (minimal JSONL to stderr) ----
+// ---- Logging (JSONL to stderr AND to LOG_FILE if set) ----
+const LOG_FILE = process.env.CODEX_BRIDGE_LOG || "";
+function writeLog(line) {
+  try { process.stderr.write(line + "\n"); } catch {}
+  if (LOG_FILE) {
+    try {
+      appendFileSync(LOG_FILE, line + "\n");
+    } catch {}
+  }
+}
 function log(level, msg, extra) {
   const line = JSON.stringify({ t: new Date().toISOString(), level, msg, ...extra });
-  process.stderr.write(line + "\n");
+  writeLog(line);
 }
 
+import { appendFileSync } from "node:fs";
+process.on("SIGPIPE", () => {});
+
 // ---- Auth handling ----
 let authCache = null;
 function loadAuth() {

package/lib/sync-cache.mjs

@@ -130,28 +130,16 @@ if (sameSet(currentSlugs, slugs)) {
   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
+// ---- 4. Rewrite the provider block, or insert a new one if missing ----
 //
-// 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);
+// Two cases:
+//   (a) `provider.<name>` already exists: rebuild just that block in place,
+//       preserving the rest of the file (comments, formatting, sibling keys).
+//   (b) `provider.<name>` is absent: append a minimal `provider` object
+//       containing only this provider, without disturbing existing keys.
+//
+// For (b) we use a custom dumper (`dump`) at the top-level prefix so the
+// inserted block matches the file's indent style.
 
 function renderModelsBlock(models, baseIndent) {
   const lines = ["{"];
@@ -170,6 +158,131 @@ function renderModelsBlock(models, baseIndent) {
   return lines.join("\n");
 }
 
+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);
+
+// Indent step (best-effort; assume 2 if we can't tell).
+function dump(obj, prefix, step = "  ") {
+  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, step)}${comma}`);
+    } else {
+      lines.push(`${innerPrefix}${JSON.stringify(k)}: ${JSON.stringify(v)}${comma}`);
+    }
+  }
+  lines.push(`${prefix}}`);
+  return lines.join("\n");
+}
+
+// Append a brand-new top-level `provider` block containing only the requested
+// provider. Does not touch existing sibling keys.
+//
+// Strategy:
+//   1. If the file has an empty `provider: {}`, fill it in.
+//   2. Otherwise, find the last TOP-LEVEL key line (e.g. `"mcp":`) and place
+//      `provider: { ... }` directly after its matching `}`, using the same
+//      indent prefix as that top-level key.
+function insertProvider(rawText, providerName, providerObj) {
+  let body = rawText.replace(/\s+$/, "");
+  const fileLE = body.includes("\r\n") ? "\r\n" : "\n";
+
+  // 1. Empty provider block?
+  const emptyProviderRE = new RegExp(`(^|\\n)([ \\t]*)"provider"\\s*:\\s*\\{\\s*\\}\\s*\\n?`);
+  if (emptyProviderRE.test(body)) {
+    const m = emptyProviderRE.exec(body);
+    const topIndent = m[2];
+    const wrapped = {};
+    wrapped[providerName] = providerObj;
+    const block = dump(wrapped, topIndent);
+    return body.replace(emptyProviderRE, `$1${topIndent}"provider": ${block}\n`);
+  }
+
+  // 2. Find the last top-level key (one whose closing `}` is followed by
+  //    the final root `}`). We pick it by walking top-level keys backwards.
+  //    Each top-level key starts at column indent and ends at the matching
+  //    `}`.
+  const lines = body.split("\n");
+  // Find every top-level key (those whose leading whitespace is the smallest
+  // amount on the line). Empirically, the file uses 2-space indent so
+  // top-level lines start with 0 spaces (root) or 2 spaces.
+  const rootDepthIndent = "  ";
+  let last = null;
+  for (let i = 0; i < lines.length; i++) {
+    const ln = lines[i];
+    const m = ln.match(/^(\s*)\"([^\"]+)\"\s*:\s*\{/);
+    if (!m) continue;
+    if (m[1] === "") continue; // this is the root `{`
+    if (m[1] !== rootDepthIndent) continue; // nested, not top level
+    last = { line: i, indent: m[1], key: m[2] };
+  }
+  if (!last) {
+    console.error("sync-cache: could not locate any top-level key to insert after");
+    return null;
+  }
+
+  // Walk from `last.line` forward to find the matching `}` of that key. We
+  // count nested braces.
+  let depth = 0;
+  let endIdx = -1;
+  let inS = false;
+  let q = "";
+  for (let i = last.line; i < lines.length; i++) {
+    for (let j = 0; j < lines[i].length; j++) {
+      const c = lines[i][j];
+      if (inS) {
+        if (c === "\\") { j++; continue; }
+        if (c === q) inS = false;
+        continue;
+      }
+      if (c === '"' || c === "'") { inS = true; q = c; continue; }
+      if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) { endIdx = i; break; }
+      }
+    }
+    if (endIdx >= 0) break;
+  }
+  if (endIdx < 0) {
+    console.error("sync-cache: could not find closing brace of last top-level key");
+    return null;
+  }
+
+  // Rebuild file with the new block inserted after `endIdx`. We MUST add
+  // a comma to the previous `}` (which is currently the last sibling of
+  // the root) and emit `"provider": { ... }` without a trailing comma
+  // because the root `}` will close it.
+  const wrapped = {};
+  wrapped[providerName] = providerObj;
+  const block = dump(wrapped, rootDepthIndent);
+  const newLines = lines.slice(0, endIdx + 1);
+  // Append a comma to the previous `}` line so the upcoming `"provider":`
+  // line is a legal sibling.
+  const prev = newLines[newLines.length - 1];
+  if (prev !== undefined && prev.includes("}") && !prev.trimEnd().endsWith(",")) {
+    newLines[newLines.length - 1] = prev.replace(/}\s*$/, "},");
+  }
+  newLines.push(`${rootDepthIndent}"provider": ${block}`);
+  const tailLines = lines.slice(endIdx + 1);
+  newLines.push(...tailLines);
+  return newLines.join(fileLE);
+}
+
 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
@@ -213,26 +326,6 @@ function replaceProvider(rawText, providerName, newProviderObj) {
   // 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.
@@ -244,18 +337,33 @@ function replaceProvider(rawText, providerName, newProviderObj) {
 
 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;
+if (!nextCfg.provider[PROVIDER]) {
+  // Case (b): create a minimal provider object from scratch.
+  nextCfg.provider[PROVIDER] = {
+    npm: "@ai-sdk/openai-compatible",
+    name: "ChatGPT Business (codex-bridge)",
+    options: { baseURL: "http://127.0.0.1:11434/v1" },
+    models: desired,
+  };
+} else {
+  nextCfg.provider[PROVIDER].models = desired;
+  // Touch `.options` only if missing — don't overwrite user config.
+  if (!nextCfg.provider[PROVIDER].options?.baseURL) {
+    nextCfg.provider[PROVIDER].options = { baseURL: "http://127.0.0.1:11434/v1" };
+  }
 }
 
-const newRaw = replaceProvider(raw, PROVIDER, nextCfg.provider[PROVIDER]);
-if (newRaw == null) {
-  console.error(`sync-cache: provider '${PROVIDER}' not found in config`);
-  process.exit(1);
+const existingProvider = cfg.provider?.[PROVIDER] || null;
+let newRaw;
+if (existingProvider) {
+  newRaw = replaceProvider(raw, PROVIDER, nextCfg.provider[PROVIDER]);
+  if (newRaw == null) {
+    console.error(`sync-cache: provider '${PROVIDER}' not found in config`);
+    process.exit(1);
+  }
+} else {
+  // Append a `provider: { <name>: {...} }` block to the root object.
+  newRaw = insertProvider(raw, PROVIDER, nextCfg.provider[PROVIDER]);
 }
 
 // Validate the new file as JSONC-roundtrip.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaralabs/codex-bridge",
-  "version": "0.1.0",
+  "version": "0.2.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",