skalpel 2.0.21 → 2.0.23

package/dist/index.js

@@ -203,6 +203,37 @@ var init_fetch_error = __esm({
   }
 });
 
+// src/proxy/trace-context.ts
+import { randomBytes } from "crypto";
+function parseTraceparent(header) {
+  if (!header) return null;
+  const trimmed = header.trim().toLowerCase();
+  const match = trimmed.match(TRACEPARENT_REGEX);
+  if (!match) return null;
+  const [, traceId, spanId, traceFlags] = match;
+  if (traceId === "00000000000000000000000000000000") return null;
+  if (spanId === "0000000000000000") return null;
+  return { traceId, spanId, traceFlags };
+}
+function generateTraceContext() {
+  return {
+    traceId: randomBytes(16).toString("hex"),
+    spanId: randomBytes(8).toString("hex"),
+    traceFlags: "01"
+    // sampled
+  };
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags}`;
+}
+var TRACEPARENT_REGEX;
+var init_trace_context = __esm({
+  "src/proxy/trace-context.ts"() {
+    "use strict";
+    TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+  }
+});
+
 // src/proxy/streaming.ts
 function parseRetryAfter(header) {
   if (!header) return void 0;
@@ -229,7 +260,7 @@ function stripSkalpelHeaders(headers) {
 async function doStreamingFetch(url, body, headers) {
   return fetch(url, { method: "POST", headers, body, dispatcher: skalpelDispatcher });
 }
-async function handleStreamingRequest(_req, res, _config, _source, body, skalpelUrl, directUrl, useSkalpel, forwardHeaders, logger) {
+async function handleStreamingRequest(_req, res, _config, _source, body, skalpelUrl, directUrl, useSkalpel, forwardHeaders, logger, traceCtx) {
   let response = null;
   let fetchError = null;
   let usedFallback = false;
@@ -350,6 +381,9 @@ data: ${JSON.stringify(envelope)}
   }
   sseHeaders["Content-Type"] = "text/event-stream";
   sseHeaders["Cache-Control"] = "no-cache";
+  if (traceCtx) {
+    sseHeaders["traceparent"] = formatTraceparent(traceCtx);
+  }
   res.writeHead(response.status, sseHeaders);
   if (!response.body) {
     res.write(`event: error
@@ -401,6 +435,7 @@ var init_streaming = __esm({
     init_envelope();
     init_recovery();
     init_fetch_error();
+    init_trace_context();
     TIMEOUT_CODES2 = /* @__PURE__ */ new Set(["ETIMEDOUT", "TIMEOUT", "UND_ERR_HEADERS_TIMEOUT"]);
     HTTP_BAD_GATEWAY = 502;
     HOP_BY_HOP = /* @__PURE__ */ new Set([
@@ -505,6 +540,7 @@ var init_ws_client = __esm({
   "src/proxy/ws-client.ts"() {
     "use strict";
     init_codex_oauth();
+    init_trace_context();
     WS_SUBPROTOCOL = "skalpel-codex-v1";
     MAX_RECONNECTS = 5;
     MAX_BACKOFF_MS = 6e4;
@@ -528,13 +564,17 @@ var init_ws_client = __esm({
         const freshToken = getFreshAccessToken();
         const bearer = freshToken ?? this.opts.oauthToken;
         return new Promise((resolve, reject) => {
+          const headers = {
+            "X-Skalpel-API-Key": this.opts.apiKey,
+            Authorization: `Bearer ${bearer}`,
+            "x-skalpel-source": this.opts.source
+          };
+          if (this.opts.traceCtx) {
+            headers["traceparent"] = formatTraceparent(this.opts.traceCtx);
+          }
           const ws = new WebSocket(this.opts.url, [WS_SUBPROTOCOL], {
             agent: pickAgent(this.opts.url),
-            headers: {
-              "X-Skalpel-API-Key": this.opts.apiKey,
-              Authorization: `Bearer ${bearer}`,
-              "x-skalpel-source": this.opts.source
-            }
+            headers
           });
           this.ws = ws;
           ws.once("unexpected-response", (_req, res) => {
@@ -689,13 +729,16 @@ async function isSkalpelBackendFailure(response, err, logger) {
     return true;
   }
 }
-function buildForwardHeaders(req, config, source, useSkalpel) {
+function buildForwardHeaders(req, config, source, useSkalpel, traceCtx) {
   const forwardHeaders = {};
   for (const [key, value] of Object.entries(req.headers)) {
     if (value === void 0) continue;
     if (FORWARD_HEADER_STRIP.has(key.toLowerCase())) continue;
     forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
   }
+  if (traceCtx) {
+    forwardHeaders["traceparent"] = formatTraceparent(traceCtx);
+  }
   if (useSkalpel) {
     forwardHeaders["X-Skalpel-API-Key"] = config.apiKey;
     forwardHeaders["X-Skalpel-Source"] = source;
@@ -760,9 +803,13 @@ async function handleRequest(req, res, config, source, logger) {
   try {
     const body = await collectBody(req);
     logger.info(`body collected bytes=${body.length}`);
+    const inboundTraceparent = req.headers["traceparent"];
+    const traceCtx = parseTraceparent(
+      typeof inboundTraceparent === "string" ? inboundTraceparent : null
+    ) ?? generateTraceContext();
     const useSkalpel = shouldRouteToSkalpel(path4, source);
-    logger.info(`routing useSkalpel=${useSkalpel}`);
-    const forwardHeaders = buildForwardHeaders(req, config, source, useSkalpel);
+    logger.info(`routing useSkalpel=${useSkalpel} traceId=${traceCtx.traceId}`);
+    const forwardHeaders = buildForwardHeaders(req, config, source, useSkalpel, traceCtx);
     logger.debug(`headers built skalpelHeaders=${useSkalpel} authConverted=${!forwardHeaders["authorization"] && !!forwardHeaders["x-api-key"]}`);
     let isStreaming = false;
     if (body) {
@@ -776,7 +823,7 @@ async function handleRequest(req, res, config, source, logger) {
     if (isStreaming) {
       const skalpelUrl2 = `${config.remoteBaseUrl}${path4}`;
       const directUrl2 = source === "claude-code" ? `${config.anthropicDirectUrl}${path4}` : source === "cursor" ? `${config.cursorDirectUrl}${path4}` : `${config.openaiDirectUrl}${path4}`;
-      await handleStreamingRequest(req, res, config, source, body, skalpelUrl2, directUrl2, useSkalpel, forwardHeaders, logger);
+      await handleStreamingRequest(req, res, config, source, body, skalpelUrl2, directUrl2, useSkalpel, forwardHeaders, logger, traceCtx);
       logger.info(`${method} ${path4} source=${source} streaming latency=${Date.now() - start}ms`);
       return;
     }
@@ -871,6 +918,7 @@ async function handleRequest(req, res, config, source, logger) {
     const responseHeaders = extractResponseHeaders(response);
     const responseBody = Buffer.from(await response.arrayBuffer());
     responseHeaders["content-length"] = String(responseBody.length);
+    responseHeaders["traceparent"] = formatTraceparent(traceCtx);
     logger.info(`response forwarding status=${response.status} bodyBytes=${responseBody.length}`);
     res.writeHead(response.status, responseHeaders);
     res.end(responseBody);
@@ -1068,7 +1116,8 @@ async function fallbackToHttp(clientWs, config, source, logger, requestBody, inb
         Authorization: authHeader,
         Accept: "text/event-stream"
       },
-      body: requestBody
+      body: requestBody,
+      dispatcher: skalpelDispatcher
     });
     if (!resp.ok) {
       let errorBody = "";
@@ -1156,6 +1205,7 @@ var init_handler = __esm({
     init_codex_oauth();
     init_recovery();
     init_fetch_error();
+    init_trace_context();
     TIMEOUT_CODES3 = /* @__PURE__ */ new Set(["ETIMEDOUT", "TIMEOUT", "UND_ERR_HEADERS_TIMEOUT"]);
     HTTP_BAD_GATEWAY2 = 502;
     SKALPEL_EXACT_PATHS = /* @__PURE__ */ new Set(["/v1/messages"]);
@@ -1855,10 +1905,12 @@ var Logger = class _Logger {
     this.log("error", msg);
   }
   /** Returns a new Logger that writes to the same file but prefixes every
-   *  emitted line with `[conn=<connId>] `. The parent logger continues to
-   *  work unchanged. IPv6 colons should already be sanitized by the caller. */
-  child(connId) {
-    const child = new _Logger(this.logFile, this.level, `[conn=${connId}] `);
+   *  emitted line with `[conn=<connId>] ` or `[conn=<connId> trace=<traceId>] `.
+   *  The parent logger continues to work unchanged. IPv6 colons should already
+   *  be sanitized by the caller. */
+  child(connId, traceId) {
+    const prefix = traceId ? `[conn=${connId} trace=${traceId}] ` : `[conn=${connId}] `;
+    const child = new _Logger(this.logFile, this.level, prefix);
     return child;
   }
   log(level, msg) {