server.mjs

#!/usr/bin/env node
import http from "node:http";
import { spawn } from "node:child_process";
import { Readable } from "node:stream";
import {
  makeTextResponse,
  makeToolResponse,
  normalizeUsage,
  streamResponse,
} from "./lib/responses.mjs";
import { runClaudeFable } from "./lib/bridge.mjs";
import { pickerCatalog } from "./lib/model-catalog.mjs";

const host = process.env.CLAUDE_FABLE_HOST ?? "127.0.0.1";
const port = Number(process.env.CLAUDE_FABLE_PORT ?? 8741);
const maxBodyBytes = Number(process.env.CLAUDE_FABLE_MAX_BODY_BYTES ?? 32 * 1024 * 1024);
let openAiAuthObserved = false;
let lastRoute = null;

const server = http.createServer(async (request, response) => {
  if (request.method === "GET" && request.url === "/health") {
    return health(response);
  }
  if (request.method === "GET" && request.url?.split("?")[0] === "/v1/models") {
    return json(response, 200, await pickerCatalog(), {
      etag: 'W/"codex-fable-adapter-picker-v1"',
    });
  }
  if (request.method !== "POST" || request.url?.split("?")[0] !== "/v1/responses") {
    return json(response, 404, { error: { message: "Not found" } });
  }

  const abortController = new AbortController();
  response.on("close", () => {
    if (!response.writableEnded) abortController.abort();
  });

  try {
    const body = await readJson(request, maxBodyBytes);
    openAiAuthObserved ||= typeof request.headers.authorization === "string";
    if (!body || typeof body !== "object") throw httpError(400, "Expected a JSON object");
    if (body.stream !== true) {
      throw httpError(400, "This adapter currently requires stream=true");
    }

    if (body.model !== "fable") {
      if (process.env.CODEX_FABLE_ENABLE_OPENAI_PASSTHROUGH !== "1") {
        throw httpError(
          400,
          "Non-Fable model routing is disabled; set CODEX_FABLE_ENABLE_OPENAI_PASSTHROUGH=1 to opt in",
        );
      }
      lastRoute = "openai";
      await proxyOpenAiResponse({ request, response, body, signal: abortController.signal });
      return;
    }

    lastRoute = "fable";

    const { decision, rawUsage } = await runClaudeFable(body, {
      signal: abortController.signal,
    });
    const usage = normalizeUsage(rawUsage);
    const completed = decision.action === "tool_call"
      ? makeToolResponse({
          model: body.model ?? "fable",
          name: decision.toolName,
          argumentsJson: decision.argumentsJson,
          usage,
        })
      : makeTextResponse({
          model: body.model ?? "fable",
          text: decision.text,
          usage,
        });
    streamResponse(response, completed);
  } catch (error) {
    if (response.headersSent || response.writableEnded) {
      response.destroy(error);
      return;
    }
    const status = Number(error.statusCode ?? 502);
    json(response, status, {
      error: {
        type: "claude_fable_adapter_error",
        message: safeErrorMessage(error),
      },
    });
  }
});

server.on("clientError", (_error, socket) => {
  socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
});

server.listen(port, host, () => {
  process.stderr.write(`Codex Fable adapter listening at http://${host}:${port}\n`);
});

function readJson(request, limit) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    let bytes = 0;
    request.on("data", (chunk) => {
      bytes += chunk.length;
      if (bytes > limit) {
        reject(httpError(413, `Request body exceeds ${limit} bytes`));
        request.destroy();
        return;
      }
      chunks.push(chunk);
    });
    request.on("end", () => {
      try {
        const raw = Buffer.concat(chunks).toString("utf8");
        resolve(JSON.parse(raw));
      } catch {
        reject(httpError(400, "Invalid JSON request body"));
      }
    });
    request.on("error", reject);
  });
}

function health(response) {
  const claude = process.env.CLAUDE_FABLE_CLI ?? "claude";
  const child = spawn(claude, ["--version"], {
    stdio: ["ignore", "ignore", "ignore"],
    env: process.env,
  });
  child.on("error", () => json(response, 503, { ok: false, claude_cli_available: false }));
  child.on("close", (code) => {
    const ok = code === 0;
    json(response, ok ? 200 : 503, {
      ok,
      claude_cli_available: ok,
      openai_auth_available: openAiAuthObserved,
      openai_passthrough_enabled:
        process.env.CODEX_FABLE_ENABLE_OPENAI_PASSTHROUGH === "1",
      last_route: lastRoute,
    });
  });
}

async function proxyOpenAiResponse({ request, response, body, signal }) {
  const upstreamBase = process.env.CODEX_OPENAI_UPSTREAM_BASE
    ?? "https://chatgpt.com/backend-api/codex";
  const headers = new Headers();
  for (const [name, value] of Object.entries(request.headers)) {
    if (value == null) continue;
    if (["host", "content-length", "connection", "accept-encoding"].includes(name)) continue;
    headers.set(name, Array.isArray(value) ? value.join(", ") : value);
  }
  headers.set("content-type", "application/json");

  const upstream = await fetch(`${upstreamBase.replace(/\/$/, "")}/responses`, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
    signal,
    redirect: "manual",
  });
  const responseHeaders = {};
  for (const name of ["content-type", "cache-control", "x-request-id", "openai-processing-ms"]) {
    const value = upstream.headers.get(name);
    if (value) responseHeaders[name] = value;
  }
  response.writeHead(upstream.status, responseHeaders);
  if (!upstream.body) {
    response.end();
    return;
  }
  await new Promise((resolve, reject) => {
    const stream = Readable.fromWeb(upstream.body);
    stream.on("error", reject);
    response.on("error", reject);
    response.on("finish", resolve);
    stream.pipe(response);
  });
}

function safeErrorMessage(error) {
  const message = String(error?.message ?? "Unknown adapter error");
  if (message.startsWith("Claude ") || message.startsWith("Unknown Claude")) return message;
  if (message.includes("JSON") || message.includes("request")) return message;
  return "Claude Fable invocation failed";
}

function httpError(statusCode, message) {
  return Object.assign(new Error(message), { statusCode });
}

function json(response, status, value, extraHeaders = {}) {
  if (response.writableEnded) return;
  const body = `${JSON.stringify(value)}\n`;
  response.writeHead(status, {
    "content-type": "application/json; charset=utf-8",
    "content-length": Buffer.byteLength(body),
    ...extraHeaders,
  });
  response.end(body);
}

for (const signal of ["SIGINT", "SIGTERM"]) {
  process.on(signal, () => server.close(() => process.exit(0)));
}