dev/scripts/openai-proxy.js

#!/usr/bin/env node
// Local OpenAI proxy replicating the upstream-merge workflow behavior.
//
// Features:
// - Injects real OPENAI_API_KEY server-side; clients can use a dummy key
// - Allows only /v1/chat/completions and /v1/responses
// - Adds OpenAI-Beta: responses=v1 for Responses API
// - Sets Accept: text/event-stream by default to stabilize streaming
// - Scrubs sensitive headers from logs; logs are structured JSON
// - Reuses connections and sets generous timeouts for SSE
//
// Usage (local):
//   # 1) Export your real API key for the proxy process
//   export OPENAI_API_KEY="sk-..."
//   # 2) Start the proxy (default port 5055)
//   node scripts/openai-proxy.js
//   #    or choose a port / upstream base
//   PORT=5055 OPENAI_BASE_URL=https://api.openai.com/v1 node scripts/openai-proxy.js
//
//   # 3) Run the local Codex binary with the proxy (dummy key to client)
//   #    Build the binary first: ./build-fast.sh
//   OPENAI_API_KEY="x" OPENAI_BASE_URL="http://127.0.0.1:${PORT:-5055}/v1" \
//     ./code-rs/target/dev-fast/code llm request \
//       --developer "Say 'pong' as plain text" \
//       --message "ping" \
//       --format-type json_schema \
//       --schema-json '{"type":"object","properties":{},"additionalProperties":false}' \
//       --model gpt-4o-mini
//
//   # Or run your usual `code` subcommand (Exec/TUI) with the same env vars.

const http = require("http");
const https = require("https");
const crypto = require("crypto");
const { URL } = require("url");

const PORT = Number(process.env.PORT || 5055);
const API_KEY = process.env.OPENAI_API_KEY || "";
const UPSTREAM = new URL(
  process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
);
const ALLOWED = ["/v1/chat/completions", "/v1/responses"];

// CI options:
//   EXIT_ON_5XX=1       -> Exit process non‑zero if a 5xx response head is seen
//   READY_FILE=path      -> Touch this file when the server is listening
//   LOG_DEST=stdout|stderr (default stdout)
// Debug toggles:
//   DISABLE_KEEPALIVE=1  -> Do not reuse upstream connections
//   FORCE_CLOSE=1         -> Send 'Connection: close' to upstream
//   NO_GZIP=1             -> Set 'accept-encoding: identity'
//   STRIP_SESSION_ID=1    -> Remove 'session_id' from upstream request headers
//   IDEMPOTENCY_KEY=auto  -> Add an Idempotency-Key header per request (uuid)
//   LOG_ERROR_BODY=1      -> Log non-2xx response body (truncated)
//   LOG_ERROR_BODY_BYTES=1024 -> Max bytes to log from error body
//   STRICT_HEADERS=1      -> Rebuild upstream headers from a minimal allowlist
//   RESPONSES_BETA="responses=v1" (override beta header)
const EXIT_ON_5XX = process.env.EXIT_ON_5XX === "1" || false;
const READY_FILE = process.env.READY_FILE || "";
const LOG_DEST = (process.env.LOG_DEST || "stdout").toLowerCase();
const DISABLE_KEEPALIVE = process.env.DISABLE_KEEPALIVE === "1" || false;
const FORCE_CLOSE = process.env.FORCE_CLOSE === "1" || false;
const NO_GZIP = process.env.NO_GZIP === "1" || false;
const STRIP_SESSION_ID = process.env.STRIP_SESSION_ID === "1" || false;
const IDEMPOTENCY_KEY = (process.env.IDEMPOTENCY_KEY || "").toLowerCase();
const LOG_ERROR_BODY = process.env.LOG_ERROR_BODY === "1" || false;
const LOG_ERROR_BODY_BYTES = Number(process.env.LOG_ERROR_BODY_BYTES || 2048);
const STRICT_HEADERS = process.env.STRICT_HEADERS === "1" || false;
const RESPONSES_BETA = process.env.RESPONSES_BETA || "responses=v1";

function outWrite(s) {
  if (LOG_DEST === "stderr") process.stderr.write(s + "\n");
  else process.stdout.write(s + "\n");
}

if (!API_KEY) {
  console.error("[fatal] OPENAI_API_KEY missing");
  process.exit(1);
}

function redactHeaders(h) {
  const out = {};
  for (const [k, v] of Object.entries(h || {})) {
    const key = k.toLowerCase();
    if (
      key === "authorization" ||
      key === "proxy-authorization" ||
      key === "cookie" ||
      key === "set-cookie"
    ) {
      out[key] = "REDACTED";
    } else {
      out[key] = Array.isArray(v) ? v.map(() => "<omitted>") : String(v);
    }
  }
  return out;
}

function log(ev) {
  try {
    outWrite(JSON.stringify({ ts: new Date().toISOString(), ...ev }));
  } catch {}
}

const server = http.createServer((req, res) => {
  const rid = crypto.randomUUID();
  if (!ALLOWED.some((p) => req.url.startsWith(p))) {
    res.writeHead(403, { "content-type": "application/json" });
    res.end(JSON.stringify({ error: "blocked", path: req.url }));
    return;
  }

  const chunks = [];
  let size = 0;
  req.on("data", (c) => {
    chunks.push(c);
    size += c.length;
    if (size > 2 * 1024 * 1024) {
      req.destroy(new Error("body too large"));
    }
  });
  req.on("error", (err) => {
    log({ level: "error", rid, msg: "client request error", err: String(err) });
    if (!res.headersSent)
      res.writeHead(400, { "content-type": "application/json" });
    res.end(JSON.stringify({ error: "bad_request" }));
  });
  req.on("end", () => {
    const body = Buffer.concat(chunks);
    const up = new URL(req.url, UPSTREAM);
    let incoming;
    if (STRICT_HEADERS) {
      incoming = {};
      incoming["authorization"] = `Bearer ${API_KEY}`;
      incoming["content-type"] = "application/json";
      incoming["accept"] = "text/event-stream";
      if (NO_GZIP) incoming["accept-encoding"] = "identity";
      if (up.pathname.startsWith("/v1/responses"))
        incoming["openai-beta"] = RESPONSES_BETA;
      incoming["user-agent"] = "code-proxy/1.0";
      incoming["originator"] = "codex_cli_rs";
      if (IDEMPOTENCY_KEY === "auto")
        incoming["idempotency-key"] = crypto.randomUUID();
    } else {
      incoming = { ...req.headers };
      if (!incoming["content-type"])
        incoming["content-type"] = "application/json";
      if (!incoming["accept"]) incoming["accept"] = "text/event-stream";
      if (NO_GZIP) incoming["accept-encoding"] = "identity";
      incoming["authorization"] = `Bearer ${API_KEY}`; // replace with real key
      if (up.pathname.startsWith("/v1/responses")) {
        if (!incoming["openai-beta"]) incoming["openai-beta"] = RESPONSES_BETA;
      }
      if (!incoming["originator"]) incoming["originator"] = "codex_cli_rs";
      if (STRIP_SESSION_ID && "session_id" in incoming)
        delete incoming["session_id"];
      if (IDEMPOTENCY_KEY === "auto")
        incoming["idempotency-key"] = crypto.randomUUID();
    }
    delete incoming["host"];
    incoming["host"] = up.host;
    incoming["connection"] = FORCE_CLOSE ? "close" : "keep-alive";
    if (incoming["content-length"])
      incoming["content-length"] = String(body.length);
    delete incoming["proxy-connection"];
    delete incoming["proxy-authorization"];

    log({
      level: "info",
      rid,
      phase: "request",
      method: req.method,
      url: up.toString(),
      headers: redactHeaders(incoming),
      body_bytes: body.length,
    });

    const opts = {
      protocol: up.protocol,
      hostname: up.hostname,
      port: up.port || (up.protocol === "https:" ? 443 : 80),
      path: up.pathname + up.search,
      method: req.method,
      headers: incoming,
      servername: up.hostname,
      agent:
        up.protocol === "https:"
          ? new https.Agent({
              keepAlive: !DISABLE_KEEPALIVE,
              maxSockets: 64,
              servername: up.hostname,
            })
          : new http.Agent({ keepAlive: !DISABLE_KEEPALIVE, maxSockets: 64 }),
    };

    const upstream = (up.protocol === "https:" ? https : http).request(
      opts,
      (upr) => {
        const resHeaders = { ...upr.headers };
        res.writeHead(upr.statusCode || 500, resHeaders);
        log({
          level: "info",
          rid,
          phase: "response_head",
          status: upr.statusCode,
          headers: redactHeaders(resHeaders),
        });
        if (EXIT_ON_5XX && upr.statusCode && upr.statusCode >= 500) {
          // Propagate response then schedule exit(2) once stream completes
          upr.on("end", () => {
            try {
              process.exitCode = 2;
            } catch {}
          });
        }
        let total = 0;
        const chunks = [];
        upr.on("data", (chunk) => {
          total += chunk.length;
          if (LOG_ERROR_BODY && upr.statusCode && upr.statusCode >= 400) {
            if (chunks.length < 32 && total <= LOG_ERROR_BODY_BYTES)
              chunks.push(chunk);
          }
        });
        upr.on("end", () => {
          if (LOG_ERROR_BODY && upr.statusCode && upr.statusCode >= 400) {
            let bodyStr = "";
            try {
              bodyStr = Buffer.concat(chunks).toString("utf8");
            } catch {}
            log({
              level: "error",
              rid,
              phase: "response_error_body",
              status: upr.statusCode,
              body: bodyStr.slice(0, LOG_ERROR_BODY_BYTES),
            });
          }
          log({
            level: "info",
            rid,
            phase: "response_end",
            status: upr.statusCode,
            bytes: total,
            request_id: resHeaders["x-request-id"] || null,
          });
        });
        upr.on("error", (e) => {
          log({ level: "error", rid, phase: "response_error", err: String(e) });
        });
        upr.pipe(res);
      },
    );
    upstream.setTimeout(600000, () => {
      upstream.destroy(new Error("upstream timeout"));
    });
    upstream.on("error", (e) => {
      log({ level: "error", rid, phase: "upstream_error", err: String(e) });
      if (!res.headersSent)
        res.writeHead(502, { "content-type": "application/json" });
      res.end(JSON.stringify({ error: "upstream_error" }));
    });
    upstream.end(body);
  });
});
server.headersTimeout = 650000;
server.keepAliveTimeout = 650000;
server.listen(PORT, "127.0.0.1", () => {
  log({ level: "info", msg: "proxy listening", addr: "127.0.0.1", port: PORT });
  if (READY_FILE) {
    try {
      require("fs").writeFileSync(READY_FILE, String(Date.now()));
    } catch {}
  }
});