@codeproxy/cli 0.1.1 → 0.2.1

package/dist/cli.cjs

@@ -0,0 +1,782 @@
+'use strict';
+
+var fs = require('fs');
+var http = require('http');
+var stream = require('stream');
+var path = require('path');
+var core = require('@codeproxy/core');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+
+// src/server/cli.ts
+function fmtTime(date) {
+  return date.toLocaleTimeString("en-US", { hour12: false });
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+async function startProxy(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 8787;
+  const cors = options.cors ?? true;
+  const logger = options.logger === null ? null : options.logger ?? console;
+  const durationHistory = [];
+  function updateRollingAverage(ms) {
+    durationHistory.push(ms);
+    if (durationHistory.length > 50) {
+      durationHistory.shift();
+    }
+    return durationHistory.reduce((sum, val) => sum + val, 0) / durationHistory.length;
+  }
+  const activeRequests = /* @__PURE__ */ new Map();
+  let statusTimerId = null;
+  function drawStatusLine() {
+    if (activeRequests.size === 0) {
+      return;
+    }
+    const parts = Array.from(activeRequests.entries()).map(([, req]) => {
+      const elapsed = Date.now() - req.startTime;
+      return `[${fmtDuration(elapsed)}]`;
+    });
+    process.stdout.write(`\r\x1B[K\u23F3 ${parts.join(", ")}`);
+  }
+  const requestTracker = {
+    add(method, url) {
+      const id = `${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+      activeRequests.set(id, { method, url, startTime: Date.now() });
+      drawStatusLine();
+      if (!statusTimerId) {
+        statusTimerId = setInterval(drawStatusLine, 150);
+      }
+      return id;
+    },
+    remove(id) {
+      activeRequests.delete(id);
+      if (activeRequests.size === 0) {
+        process.stdout.write("\r\x1B[K");
+        if (statusTimerId) {
+          clearInterval(statusTimerId);
+          statusTimerId = null;
+        }
+      }
+    }
+  };
+  const requestInfo = { method: "", url: "", startTime: 0, resultLog: "" };
+  const upstreamCapture = {};
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const capturingFetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (init?.method ?? input?.method ?? "GET").toUpperCase();
+    const reqHeaders = headersInitToObject(init?.headers);
+    let reqBody = void 0;
+    if (init?.body != null) {
+      if (typeof init.body === "string") {
+        reqBody = tryParseJson(init.body);
+      } else if (init.body instanceof ArrayBuffer) {
+        reqBody = tryParseJson(new TextDecoder().decode(init.body));
+      } else if (ArrayBuffer.isView(init.body)) {
+        reqBody = tryParseJson(new TextDecoder().decode(init.body));
+      } else {
+        reqBody = String(init.body);
+      }
+    }
+    upstreamCapture.request = { url, method, headers: reqHeaders, body: reqBody };
+    const resp = await baseFetch(input, init);
+    if (!resp.ok) {
+      const clone = resp.clone();
+      const text = await clone.text().catch(() => "");
+      upstreamCapture.response = {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers: headersToObject(resp.headers),
+        body: tryParseJson(text)
+      };
+    } else {
+      upstreamCapture.response = void 0;
+    }
+    return resp;
+  };
+  const apiFetch = core.createResponsesFetch({
+    upstreamFormat: options.upstreamFormat,
+    baseUrl: options.baseUrl,
+    apiVersion: options.apiVersion,
+    model: options.model,
+    defaultHeaders: options.defaultHeaders,
+    timeoutMs: options.timeoutMs,
+    dropImages: options.dropImages,
+    fallbackUpstream: options.fallbackUpstream,
+    fetch: capturingFetch,
+    passthroughFetch: async () => new Response(JSON.stringify({ error: { message: "Not found" } }), {
+      status: 404,
+      headers: { "content-type": "application/json" }
+    }),
+    onCacheStats: (stats) => {
+      const durationMs = requestInfo.startTime ? Date.now() - requestInfo.startTime : 0;
+      const billedTokens = stats.inputTokens + stats.outputTokens - stats.cachedTokens;
+      const parts = [
+        `total=${stats.totalTokens}`,
+        `input=${stats.inputTokens}`,
+        `output=${stats.outputTokens}`,
+        `cached=${stats.cachedTokens}`,
+        `billed=${billedTokens}`
+      ];
+      if (stats.cacheCreationTokens > 0) {
+        parts.push(`cache_creation=${stats.cacheCreationTokens}`);
+      }
+      const avg = updateRollingAverage(durationMs);
+      const ratio = avg > 0 ? durationMs / avg : 1;
+      const color = ratio < 0.8 ? "\x1B[32m" : ratio < 1.5 ? "\x1B[33m" : "\x1B[31m";
+      const reset = "\x1B[0m";
+      const logMsg = `[${fmtTime(/* @__PURE__ */ new Date())}] -> 200 (${color}${fmtDuration(durationMs)}${reset} avg=${fmtDuration(Math.round(avg))}) [${parts.join(", ")}]`;
+      requestInfo.resultLog = stats.cachedTokens < 1024 && billedTokens > 0 ? `\u26A0\uFE0F NO CACHE -- ${logMsg}` : logMsg;
+      if (options.onCacheStats) {
+        options.onCacheStats({
+          ...stats,
+          method: requestInfo.method || void 0,
+          url: requestInfo.url || void 0,
+          durationMs: durationMs || void 0
+        });
+      }
+    }
+  });
+  const server = http__default.default.createServer(async (req, res) => {
+    const start = Date.now();
+    requestInfo.method = req.method ?? "POST";
+    requestInfo.url = req.url ?? "/v1/responses";
+    requestInfo.startTime = start;
+    const abortController = new AbortController();
+    const timeoutMs = options.timeoutMs;
+    let timeoutTimer;
+    if (timeoutMs && timeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        logger?.warn(`[timeout] request exceeded ${timeoutMs}ms, aborting`);
+        abortController.abort();
+        res.destroy();
+        req.destroy();
+      }, timeoutMs);
+    }
+    try {
+      await handleRequest(req, res, {
+        apiFetch,
+        cors,
+        logger,
+        method: req.method ?? "POST",
+        url: req.url ?? "/",
+        upstreamCapture,
+        requestInfo,
+        requestTracker,
+        signal: abortController.signal
+      });
+    } catch (err) {
+      logger?.error("[proxy-error]", err);
+      try {
+        if (!res.headersSent) {
+          res.writeHead(500, { "content-type": "application/json" });
+          res.end(JSON.stringify({ error: { message: "Internal server error" } }));
+        }
+      } catch {
+      }
+    } finally {
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+      }
+    }
+  });
+  return new Promise((resolve3, reject) => {
+    server.listen(port, host, () => {
+      const actualPort = (() => {
+        const addr = server.address();
+        return addr.port;
+      })();
+      const url = `http://${host}:${actualPort}`;
+      logger?.log(`Proxy listening on ${url}`);
+      logger?.log(`Upstream format: ${options.upstreamFormat}`);
+      logger?.log(`Upstream URL: ${options.baseUrl}`);
+      resolve3({
+        host,
+        port: actualPort,
+        url,
+        server,
+        close: () => new Promise((res) => {
+          server.close((err) => {
+            if (err) {
+              logger?.warn("Error closing server:", err);
+            }
+            res();
+          });
+        })
+      });
+    });
+    server.once("error", reject);
+  });
+}
+async function handleRequest(req, res, opts) {
+  if (opts.cors) {
+    setCorsHeaders(res);
+  }
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  const method = req.method ?? "GET";
+  const urlPath = req.url ?? "/";
+  const headers = flattenIncomingHeaders(req.headers);
+  let body;
+  if (method !== "GET" && method !== "HEAD") {
+    body = await readIncomingBody(req);
+  }
+  if (!/^\/v1\/responses\/?(?:\?|$)/.test(urlPath)) {
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: { message: `Not found: ${method} ${urlPath}` } }));
+    return;
+  }
+  const requestBodyText = body ? body.toString("utf8") : void 0;
+  const requestStart = Date.now();
+  const requestId = opts.requestTracker.add(method, urlPath);
+  try {
+    const response = await opts.apiFetch(`http://local${urlPath}`, {
+      method,
+      headers,
+      body: body ? new Uint8Array(body) : void 0,
+      signal: opts.signal
+    });
+    const responseBodyText = response.body ? await response.clone().text() : "";
+    opts.requestTracker.remove(requestId);
+    if (opts.logger) {
+      if (response.status >= 400) {
+        process.stdout.write(
+          `\r\x1B[K<-- ${response.status}  (${fmtDuration(Date.now() - requestStart)})
+`
+        );
+      } else if (opts.requestInfo.resultLog) {
+        process.stdout.write(`\r\x1B[K${opts.requestInfo.resultLog}
+`);
+      } else {
+        process.stdout.write(
+          `\r\x1B[K<-- ${response.status}  (${fmtDuration(Date.now() - requestStart)})
+`
+        );
+      }
+    }
+    if (response.status >= 400) {
+      try {
+        const filePath = saveErrorDump({
+          method: opts.method,
+          url: opts.url,
+          clientRequest: {
+            headers,
+            body: tryParseJson(requestBodyText ?? "")
+          },
+          upstreamRequest: opts.upstreamCapture.request,
+          upstreamResponse: opts.upstreamCapture.response,
+          proxyResponse: {
+            status: response.status,
+            headers: headersToObject(response.headers),
+            body: tryParseJson(responseBodyText)
+          }
+        });
+        opts.logger?.error(`[proxy-failure] full exchange saved to ${filePath}`);
+      } catch (dumpErr) {
+        opts.logger?.error("[proxy-failure] failed to persist error dump", dumpErr);
+      }
+    }
+    const outHeaders = {};
+    response.headers.forEach((value, key) => {
+      outHeaders[key] = value;
+    });
+    if (opts.cors) {
+      Object.assign(outHeaders, corsHeaders());
+    }
+    res.writeHead(response.status, outHeaders);
+    if (!response.body) {
+      res.end();
+      return;
+    }
+    const typedBody = response.body;
+    const nodeStream = stream.Readable.fromWeb(typedBody);
+    nodeStream.pipe(res);
+    await new Promise((resolve3, reject) => {
+      nodeStream.once("end", resolve3);
+      nodeStream.once("error", reject);
+      res.once("close", resolve3);
+    });
+  } catch (err) {
+    opts.requestTracker.remove(requestId);
+    throw err;
+  }
+}
+function readIncomingBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => {
+      const buf = chunk;
+      chunks.push(buf);
+    });
+    req.on("end", () => resolve3(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function flattenIncomingHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value == null) {
+      continue;
+    }
+    out[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return out;
+}
+function headersToObject(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+}
+function setCorsHeaders(res) {
+  const headers = corsHeaders();
+  for (const [key, value] of Object.entries(headers)) {
+    res.setHeader(key, value);
+  }
+}
+function corsHeaders() {
+  return {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "authorization,content-type,x-api-key,anthropic-version,anthropic-beta,anthropic-dangerous-direct-browser-access",
+    "access-control-expose-headers": "content-type"
+  };
+}
+function tryParseJson(str) {
+  if (!str) {
+    return str ?? null;
+  }
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+function headersInitToObject(headersInit) {
+  const out = {};
+  if (!headersInit) {
+    return out;
+  }
+  if (typeof Headers !== "undefined" && headersInit instanceof Headers) {
+    headersInit.forEach((value, key) => {
+      out[key.toLowerCase()] = value;
+    });
+    return out;
+  }
+  if (Array.isArray(headersInit)) {
+    for (const [key, value] of headersInit) {
+      out[String(key).toLowerCase()] = String(value);
+    }
+    return out;
+  }
+  for (const [key, value] of Object.entries(headersInit)) {
+    out[key.toLowerCase()] = String(value);
+  }
+  return out;
+}
+function saveErrorDump(dump) {
+  const dir = path.resolve(process.cwd(), "logs");
+  fs.mkdirSync(dir, { recursive: true });
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const status = dump.upstreamResponse?.status ?? dump.proxyResponse.status;
+  const filename = `proxy-error-${ts}-${status}.json`;
+  const filePath = path.join(dir, filename);
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...dump
+  };
+  redactAuth(payload.clientRequest?.headers);
+  redactAuth(payload.upstreamRequest?.headers);
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+  return filePath;
+}
+function redactAuth(headers) {
+  if (!headers) {
+    return;
+  }
+  for (const key of Object.keys(headers)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey === "authorization" || lowerKey === "x-api-key" || lowerKey === "api-key" || lowerKey === "cookie") {
+      headers[key] = "[REDACTED]";
+    }
+  }
+}
+function validateConfig(config) {
+  if (typeof config !== "object" || config === null) {
+    return { valid: false, error: "Config must be an object" };
+  }
+  const cfg = config;
+  if (typeof cfg.version !== "string") {
+    return { valid: false, error: "Config must have a version string" };
+  }
+  if (typeof cfg.currentUpstream !== "string") {
+    return { valid: false, error: "Config must have a currentUpstream string" };
+  }
+  if (typeof cfg.upstreams !== "object" || cfg.upstreams === null) {
+    return { valid: false, error: "Config must have an upstreams object" };
+  }
+  const upstreams = cfg.upstreams;
+  if (!(cfg.currentUpstream in upstreams)) {
+    return {
+      valid: false,
+      error: `currentUpstream "${cfg.currentUpstream}" not found in upstreams`
+    };
+  }
+  for (const [name, upstream] of Object.entries(upstreams)) {
+    const result = validateUpstreamConfig(upstream);
+    if (!result.valid) {
+      return {
+        valid: false,
+        error: `Upstream "${name}" is invalid: ${result.error}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function validateUpstreamConfig(upstream) {
+  if (typeof upstream !== "object" || upstream === null) {
+    return { valid: false, error: "Upstream config must be an object" };
+  }
+  const cfg = upstream;
+  if (cfg.format !== void 0) {
+    if (typeof cfg.format !== "string") {
+      return { valid: false, error: "format must be a string if provided" };
+    }
+    const validFormats = ["anthropic", "openai-chat"];
+    if (!validFormats.includes(cfg.format)) {
+      return {
+        valid: false,
+        error: `Invalid format: ${cfg.format}. Must be one of: ${validFormats.join(", ")}`
+      };
+    }
+  }
+  if (typeof cfg.baseUrl !== "string") {
+    return { valid: false, error: "baseUrl is required and must be a string" };
+  }
+  if (cfg.apiVersion !== void 0 && typeof cfg.apiVersion !== "string") {
+    return { valid: false, error: "apiVersion must be a string if provided" };
+  }
+  if (cfg.apiKey !== void 0 && typeof cfg.apiKey !== "string") {
+    return { valid: false, error: "apiKey must be a string if provided" };
+  }
+  if (cfg.model !== void 0 && typeof cfg.model !== "string") {
+    return { valid: false, error: "model must be a string if provided" };
+  }
+  if (cfg.dropImages !== void 0 && typeof cfg.dropImages !== "boolean") {
+    return { valid: false, error: "dropImages must be a boolean if provided" };
+  }
+  if (cfg.fallback !== void 0 && typeof cfg.fallback !== "string") {
+    return { valid: false, error: "fallback must be a string if provided" };
+  }
+  if (cfg.headers !== void 0 && (typeof cfg.headers !== "object" || cfg.headers === null)) {
+    return { valid: false, error: "headers must be an object if provided" };
+  }
+  if (cfg.reasoningEffort !== void 0 && typeof cfg.reasoningEffort !== "string") {
+    return { valid: false, error: "reasoningEffort must be a string if provided" };
+  }
+  return { valid: true };
+}
+function getCurrentUpstreamConfig(config) {
+  const upstream = config.upstreams[config.currentUpstream];
+  if (!upstream) {
+    return null;
+  }
+  return upstream;
+}
+
+// src/server/cli.ts
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const take = () => argv[++i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        out.help = true;
+        break;
+      case "-p":
+      case "--port":
+        out.port = Number(take());
+        break;
+      case "--host":
+        out.host = take();
+        break;
+      case "--upstream-format":
+        out.upstreamFormat = take();
+        break;
+      case "--base-url":
+        out.baseUrl = take();
+        break;
+      case "--config":
+        out.config = take();
+        break;
+      case "--api-version":
+        out.apiVersion = take();
+        break;
+      case "--apikey":
+        out.apikey = take();
+        break;
+      case "--model":
+        out.model = take();
+        break;
+      case "--drop-images":
+        out.dropImages = true;
+        break;
+      case "--no-cors":
+        out.cors = false;
+        break;
+      default:
+        if (arg.startsWith("--upstream-format=")) {
+          out.upstreamFormat = arg.slice("--upstream-format=".length);
+        } else if (arg.startsWith("--port=")) {
+          out.port = Number(arg.slice("--port=".length));
+        } else if (arg.startsWith("--host=")) {
+          out.host = arg.slice("--host=".length);
+        } else if (arg.startsWith("--base-url=")) {
+          out.baseUrl = arg.slice("--base-url=".length);
+        } else if (arg.startsWith("--api-version=")) {
+          out.apiVersion = arg.slice("--api-version=".length);
+        } else if (arg.startsWith("--apikey=")) {
+          out.apikey = arg.slice("--apikey=".length);
+        } else if (arg.startsWith("--model=")) {
+          out.model = arg.slice("--model=".length);
+        } else if (arg.startsWith("--config=")) {
+          out.config = arg.slice("--config=".length);
+        } else {
+          console.error(`Unknown argument: ${arg}`);
+          out.help = true;
+        }
+    }
+  }
+  return out;
+}
+function printHelp() {
+  console.log(`codeproxy - local Responses API proxy
+
+Usage:
+  codeproxy --base-url <url> [options]
+  codeproxy --config <file> [options]
+
+Options:
+  --base-url <url>         Upstream endpoint URL (required when not using --config)
+  --upstream-format <fmt>  Upstream API format: anthropic | openai-chat
+                           (optional; inferred from --base-url when omitted:
+                            */messages or *anthropic* \u2192 anthropic,
+                            */chat/completions \u2192 openai-chat)
+  --config <file>          Use a config file instead of CLI flags
+  --host <host>            Bind host (default: 127.0.0.1)
+  -p, --port <port>        Bind port (default: 8787; 0 = random)
+  --api-version <ver>      Override anthropic-version header (anthropic only)
+  --apikey <key>           Override upstream Authorization: Bearer <key>
+  --model <name>           Override the model field in incoming requests
+  --no-cors                Disable CORS headers
+  -h, --help               Show help
+
+Config File Mode:
+  When using --config, upstream settings are loaded from the config file.
+  Command-line options can override config values.
+
+  Config file format (JSON):
+  {
+    "version": "1.0",
+    "currentUpstream": "my-claude",
+    "upstreams": {
+      "my-claude": {
+        "baseUrl": "https://api.anthropic.com/v1/messages",
+        "apiKey": "your-api-key",
+        "model": "claude-sonnet-4-5"
+      },
+      "my-openai": {
+        "baseUrl": "https://api.openai.com/v1/chat/completions",
+        "apiKey": "your-openai-key"
+      }
+    }
+  }
+
+  "format" is optional; inferred from baseUrl when omitted.
+
+Auth is caller-driven: send Authorization: Bearer <key> (or the upstream's
+native header) when calling the proxy. Nothing is stored server-side.
+
+Examples:
+  codeproxy --upstream-format anthropic --base-url https://api.anthropic.com/v1/messages
+  codeproxy --upstream-format openai-chat --base-url https://api.openai.com/v1/chat/completions
+  codeproxy --config my-config.json
+  codeproxy --upstream-format anthropic --base-url https://api.anthropic.com/v1/messages --apikey <key>
+`);
+}
+async function loadConfigFile(configPath) {
+  if (!fs.existsSync(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    process.exit(1);
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return parsed;
+  } catch (error) {
+    console.error(`Failed to load config from ${configPath}:`, error);
+    process.exit(1);
+  }
+}
+async function loadConfigAndApplyOverrides(configPath, overrides) {
+  const config = await loadConfigFile(configPath);
+  const validation = validateConfig(config);
+  if (!validation.valid) {
+    console.error(`Invalid config file: ${validation.error}`);
+    process.exit(1);
+  }
+  const upstreamConfig = getCurrentUpstreamConfig(config);
+  if (!upstreamConfig) {
+    console.error(`Current upstream "${config.currentUpstream}" not found in config`);
+    process.exit(1);
+  }
+  console.log(`Loaded config from: ${configPath}`);
+  console.log(
+    `Current upstream: ${config.currentUpstream}${upstreamConfig.format ? ` (${upstreamConfig.format})` : ""}`
+  );
+  console.log(`Model: ${upstreamConfig.model || "(not set)"}`);
+  const mergedEffort = upstreamConfig.reasoningEffort ?? config.reasoningEffort;
+  if (mergedEffort) {
+    console.log(`Reasoning effort: ${mergedEffort}`);
+  }
+  const mergedHeaders = { ...config.headers ?? {} };
+  if (upstreamConfig.headers) {
+    Object.assign(mergedHeaders, upstreamConfig.headers);
+  }
+  if (mergedHeaders.authorization) {
+    mergedHeaders.authorization = '"[REDACTED]"';
+  }
+  if (Object.keys(mergedHeaders).length > 0) {
+    console.log(`Headers: ${JSON.stringify(mergedHeaders)}`);
+  }
+  const options = {
+    upstreamFormat: upstreamConfig.format,
+    baseUrl: overrides.baseUrl || upstreamConfig.baseUrl,
+    apiVersion: overrides.apiVersion || upstreamConfig.apiVersion,
+    model: overrides.model || upstreamConfig.model,
+    host: overrides.host || upstreamConfig.host,
+    port: overrides.port !== void 0 ? overrides.port : (
+      // eslint-disable-next-line no-restricted-syntax -- access dynamic config key
+      config.port ? (
+        // eslint-disable-next-line no-restricted-syntax -- access dynamic config key
+        Number(config.port)
+      ) : upstreamConfig.port ? Number(upstreamConfig.port) : void 0
+    ),
+    timeoutMs: upstreamConfig.timeoutMs ?? config.timeoutMs,
+    dropImages: upstreamConfig.dropImages,
+    cors: overrides.cors,
+    reasoning_effort: upstreamConfig.reasoningEffort ?? config.reasoningEffort,
+    thinking: upstreamConfig.thinking ?? config.thinking
+  };
+  const defaultHeaders = { ...config.headers ?? {} };
+  if (upstreamConfig.headers) {
+    Object.assign(defaultHeaders, upstreamConfig.headers);
+  }
+  if (upstreamConfig.apiKey) {
+    defaultHeaders.authorization = `Bearer ${upstreamConfig.apiKey}`;
+  }
+  if (overrides.apikey) {
+    defaultHeaders.authorization = `Bearer ${overrides.apikey}`;
+  }
+  if (Object.keys(defaultHeaders).length > 0) {
+    options.defaultHeaders = defaultHeaders;
+  }
+  if (upstreamConfig.fallback) {
+    const fbConfig = config.upstreams[upstreamConfig.fallback];
+    if (fbConfig) {
+      const fbHeaders = { ...config.headers ?? {} };
+      if (fbConfig.headers) {
+        Object.assign(fbHeaders, fbConfig.headers);
+      }
+      if (fbConfig.apiKey) {
+        fbHeaders.authorization = `Bearer ${fbConfig.apiKey}`;
+      }
+      const fbFormat = fbConfig.format;
+      options.fallbackUpstream = {
+        baseUrl: fbConfig.baseUrl,
+        upstreamFormat: fbFormat,
+        model: fbConfig.model ?? options.model,
+        defaultHeaders: Object.keys(fbHeaders).length > 0 ? fbHeaders : void 0,
+        apiVersion: fbConfig.apiVersion ?? options.apiVersion,
+        reasoning_effort: fbConfig.reasoningEffort ?? options.reasoning_effort,
+        thinking: fbConfig.thinking ?? options.thinking
+      };
+      console.log(
+        `Fallback upstream: ${upstreamConfig.fallback}${fbConfig.model ? ` (${fbConfig.model})` : ""}`
+      );
+    } else {
+      console.warn(`Warning: fallback upstream "${upstreamConfig.fallback}" not found in config`);
+    }
+  }
+  return options;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  let options;
+  if (args.config) {
+    options = await loadConfigAndApplyOverrides(args.config, args);
+  } else if (args.baseUrl) {
+    const upstreamFormat = args.upstreamFormat;
+    options = {
+      upstreamFormat,
+      baseUrl: args.baseUrl,
+      host: args.host,
+      port: args.port,
+      apiVersion: args.apiVersion,
+      model: args.model,
+      defaultHeaders: args.apikey ? { authorization: `Bearer ${args.apikey}` } : void 0,
+      dropImages: args.dropImages,
+      cors: args.cors
+    };
+  } else {
+    console.error("Error: Either --config <file> or --base-url <url> is required");
+    console.error("");
+    printHelp();
+    process.exit(1);
+  }
+  const proxy = await startProxy(options);
+  const shutdown = async (signal) => {
+    console.log(`
+Received ${signal}, shutting down...`);
+    try {
+      await proxy.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+if (process.argv[1]?.endsWith("cli.js") || process.argv[1]?.endsWith("cli.ts")) {
+  void main();
+}
+
+exports.loadConfigAndApplyOverrides = loadConfigAndApplyOverrides;
+exports.loadConfigFile = loadConfigFile;
+exports.main = main;
+exports.parseArgs = parseArgs;
+exports.printHelp = printHelp;
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map