skalpel 2.0.6 → 2.0.7

package/dist/index.cjs

@@ -509,42 +509,84 @@ async function createSkalpelAnthropic(options) {
 var import_node_http = __toESM(require("http"), 1);
 
 // src/proxy/streaming.ts
-async function handleStreamingRequest(_req, res, _config, _source, body, forwardUrl, forwardHeaders, logger) {
-  const HOP_BY_HOP = /* @__PURE__ */ new Set([
-    "connection",
-    "keep-alive",
-    "proxy-authenticate",
-    "proxy-authorization",
-    "te",
-    "trailer",
-    "transfer-encoding",
-    "upgrade"
-  ]);
-  let response;
-  try {
-    response = await fetch(forwardUrl, {
-      method: "POST",
-      headers: forwardHeaders,
-      body
-    });
-  } catch (err) {
-    logger.error(`streaming fetch failed: ${err.message}`);
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var STRIP_HEADERS = /* @__PURE__ */ new Set([
+  ...HOP_BY_HOP,
+  "content-encoding",
+  "content-length"
+]);
+function stripSkalpelHeaders(headers) {
+  const cleaned = { ...headers };
+  delete cleaned["X-Skalpel-API-Key"];
+  delete cleaned["X-Skalpel-Source"];
+  delete cleaned["X-Skalpel-Agent-Type"];
+  delete cleaned["X-Skalpel-SDK-Version"];
+  return cleaned;
+}
+function isSkalpelBackendFailure(response, err) {
+  if (err) return true;
+  if (!response) return true;
+  if (response.status >= 500) return true;
+  return false;
+}
+async function doStreamingFetch(url, body, headers) {
+  return fetch(url, { method: "POST", headers, body });
+}
+async function handleStreamingRequest(_req, res, _config, _source, body, skalpelUrl, directUrl, useSkalpel, forwardHeaders, logger) {
+  let response = null;
+  let fetchError = null;
+  let usedFallback = false;
+  if (useSkalpel) {
+    try {
+      response = await doStreamingFetch(skalpelUrl, body, forwardHeaders);
+    } catch (err) {
+      fetchError = err;
+    }
+    if (isSkalpelBackendFailure(response, fetchError)) {
+      logger.warn(`streaming: Skalpel backend failed (${fetchError ? fetchError.message : `status ${response?.status}`}), falling back to direct Anthropic API`);
+      usedFallback = true;
+      response = null;
+      fetchError = null;
+      const directHeaders = stripSkalpelHeaders(forwardHeaders);
+      try {
+        response = await doStreamingFetch(directUrl, body, directHeaders);
+      } catch (err) {
+        fetchError = err;
+      }
+    }
+  } else {
+    try {
+      response = await doStreamingFetch(directUrl, body, forwardHeaders);
+    } catch (err) {
+      fetchError = err;
+    }
+  }
+  if (!response || fetchError) {
+    const errMsg = fetchError ? fetchError.message : "no response from upstream";
+    logger.error(`streaming fetch failed: ${errMsg}`);
     res.writeHead(502, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache"
     });
     res.write(`event: error
-data: ${JSON.stringify({ error: err.message })}
+data: ${JSON.stringify({ error: errMsg })}
 
 `);
     res.end();
     return;
   }
-  const STRIP_HEADERS = /* @__PURE__ */ new Set([
-    ...HOP_BY_HOP,
-    "content-encoding",
-    "content-length"
-  ]);
+  if (usedFallback) {
+    logger.info("streaming: using direct Anthropic API fallback");
+  }
   if (response.status >= 300) {
     const errorBody = Buffer.from(await response.arrayBuffer());
     logger.error(`streaming upstream error: status=${response.status} body=${errorBody.toString().slice(0, 500)}`);
@@ -610,6 +652,67 @@ function shouldRouteToSkalpel(path4, source) {
   const pathname = path4.split("?")[0];
   return SKALPEL_EXACT_PATHS.has(pathname);
 }
+function isSkalpelBackendFailure2(response, err) {
+  if (err) return true;
+  if (!response) return true;
+  if (response.status >= 500) return true;
+  return false;
+}
+function buildForwardHeaders(req, config, source, useSkalpel) {
+  const forwardHeaders = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value !== void 0) {
+      forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  delete forwardHeaders["host"];
+  delete forwardHeaders["connection"];
+  if (useSkalpel) {
+    forwardHeaders["X-Skalpel-API-Key"] = config.apiKey;
+    forwardHeaders["X-Skalpel-Source"] = source;
+    forwardHeaders["X-Skalpel-Agent-Type"] = source;
+    forwardHeaders["X-Skalpel-SDK-Version"] = "proxy-1.0.0";
+    if (source === "claude-code" && !forwardHeaders["x-api-key"]) {
+      const authHeader = forwardHeaders["authorization"] ?? "";
+      if (authHeader.toLowerCase().startsWith("bearer ")) {
+        const token = authHeader.slice(7).trim();
+        if (token.startsWith("sk-ant-")) {
+          forwardHeaders["x-api-key"] = token;
+        }
+      }
+    }
+  }
+  return forwardHeaders;
+}
+function stripSkalpelHeaders2(headers) {
+  const cleaned = { ...headers };
+  delete cleaned["X-Skalpel-API-Key"];
+  delete cleaned["X-Skalpel-Source"];
+  delete cleaned["X-Skalpel-Agent-Type"];
+  delete cleaned["X-Skalpel-SDK-Version"];
+  return cleaned;
+}
+var STRIP_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "content-encoding",
+  "content-length"
+]);
+function extractResponseHeaders(response) {
+  const headers = {};
+  for (const [key, value] of response.headers.entries()) {
+    if (!STRIP_RESPONSE_HEADERS.has(key)) {
+      headers[key] = value;
+    }
+  }
+  return headers;
+}
 async function handleRequest(req, res, config, source, logger) {
   const start = Date.now();
   const method = req.method ?? "GET";
@@ -617,30 +720,7 @@ async function handleRequest(req, res, config, source, logger) {
   try {
     const body = await collectBody(req);
     const useSkalpel = shouldRouteToSkalpel(path4, source);
-    const forwardUrl = `${useSkalpel ? config.remoteBaseUrl : config.anthropicDirectUrl}${path4}`;
-    const forwardHeaders = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (value !== void 0) {
-        forwardHeaders[key] = Array.isArray(value) ? value.join(", ") : value;
-      }
-    }
-    delete forwardHeaders["host"];
-    delete forwardHeaders["connection"];
-    if (useSkalpel) {
-      forwardHeaders["X-Skalpel-API-Key"] = config.apiKey;
-      forwardHeaders["X-Skalpel-Source"] = source;
-      forwardHeaders["X-Skalpel-Agent-Type"] = source;
-      forwardHeaders["X-Skalpel-SDK-Version"] = "proxy-1.0.0";
-      if (source === "claude-code" && !forwardHeaders["x-api-key"]) {
-        const authHeader = forwardHeaders["authorization"] ?? "";
-        if (authHeader.toLowerCase().startsWith("bearer ")) {
-          const token = authHeader.slice(7).trim();
-          if (token.startsWith("sk-ant-")) {
-            forwardHeaders["x-api-key"] = token;
-          }
-        }
-      }
-    }
+    const forwardHeaders = buildForwardHeaders(req, config, source, useSkalpel);
     let isStreaming = false;
     if (body) {
       try {
@@ -650,38 +730,52 @@ async function handleRequest(req, res, config, source, logger) {
       }
     }
     if (isStreaming) {
-      await handleStreamingRequest(req, res, config, source, body, forwardUrl, forwardHeaders, logger);
+      const skalpelUrl2 = `${config.remoteBaseUrl}${path4}`;
+      const directUrl2 = `${config.anthropicDirectUrl}${path4}`;
+      await handleStreamingRequest(req, res, config, source, body, skalpelUrl2, directUrl2, useSkalpel, forwardHeaders, logger);
       logger.info(`${method} ${path4} source=${source} streaming latency=${Date.now() - start}ms`);
       return;
     }
-    const response = await fetch(forwardUrl, {
-      method,
-      headers: forwardHeaders,
-      body: method !== "GET" && method !== "HEAD" ? body : void 0
-    });
-    const STRIP_HEADERS = /* @__PURE__ */ new Set([
-      "connection",
-      "keep-alive",
-      "proxy-authenticate",
-      "proxy-authorization",
-      "te",
-      "trailer",
-      "transfer-encoding",
-      "upgrade",
-      "content-encoding",
-      "content-length"
-    ]);
-    const responseHeaders = {};
-    for (const [key, value] of response.headers.entries()) {
-      if (!STRIP_HEADERS.has(key)) {
-        responseHeaders[key] = value;
+    const skalpelUrl = `${config.remoteBaseUrl}${path4}`;
+    const directUrl = `${config.anthropicDirectUrl}${path4}`;
+    const fetchBody = method !== "GET" && method !== "HEAD" ? body : void 0;
+    let response = null;
+    let fetchError = null;
+    let usedFallback = false;
+    if (useSkalpel) {
+      try {
+        response = await fetch(skalpelUrl, { method, headers: forwardHeaders, body: fetchBody });
+      } catch (err) {
+        fetchError = err;
+      }
+      if (isSkalpelBackendFailure2(response, fetchError)) {
+        logger.warn(`${method} ${path4} Skalpel backend failed (${fetchError ? fetchError.message : `status ${response?.status}`}), falling back to direct Anthropic API`);
+        usedFallback = true;
+        response = null;
+        fetchError = null;
+        const directHeaders = stripSkalpelHeaders2(forwardHeaders);
+        try {
+          response = await fetch(directUrl, { method, headers: directHeaders, body: fetchBody });
+        } catch (err) {
+          fetchError = err;
+        }
+      }
+    } else {
+      try {
+        response = await fetch(directUrl, { method, headers: forwardHeaders, body: fetchBody });
+      } catch (err) {
+        fetchError = err;
       }
     }
+    if (!response || fetchError) {
+      throw fetchError ?? new Error("no response from upstream");
+    }
+    const responseHeaders = extractResponseHeaders(response);
     const responseBody = Buffer.from(await response.arrayBuffer());
     responseHeaders["content-length"] = String(responseBody.length);
     res.writeHead(response.status, responseHeaders);
     res.end(responseBody);
-    logger.info(`${method} ${path4} source=${source} status=${response.status} latency=${Date.now() - start}ms`);
+    logger.info(`${method} ${path4} source=${source} status=${response.status}${usedFallback ? " (fallback)" : ""} latency=${Date.now() - start}ms`);
   } catch (err) {
     logger.error(`${method} ${path4} source=${source} error=${err.message}`);
     if (!res.headersSent) {
@@ -815,6 +909,24 @@ function startProxy(config) {
     }
     handleRequest(req, res, config, "codex", logger);
   });
+  anthropicServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      logger.error(`Port ${config.anthropicPort} is already in use. Another Skalpel proxy or process may be running.`);
+    } else {
+      logger.error(`Anthropic proxy failed to bind port ${config.anthropicPort}: ${err.message}`);
+    }
+    removePid(config.pidFile);
+    process.exit(1);
+  });
+  openaiServer.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      logger.error(`Port ${config.openaiPort} is already in use. Another Skalpel proxy or process may be running.`);
+    } else {
+      logger.error(`OpenAI proxy failed to bind port ${config.openaiPort}: ${err.message}`);
+    }
+    removePid(config.pidFile);
+    process.exit(1);
+  });
   anthropicServer.listen(config.anthropicPort, () => {
     logger.info(`Anthropic proxy listening on port ${config.anthropicPort}`);
   });
@@ -832,6 +944,16 @@ function startProxy(config) {
   };
   process.on("SIGTERM", cleanup);
   process.on("SIGINT", cleanup);
+  process.on("uncaughtException", (err) => {
+    logger.error(`Uncaught exception: ${err.message}`);
+    removePid(config.pidFile);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.error(`Unhandled rejection: ${reason}`);
+    removePid(config.pidFile);
+    process.exit(1);
+  });
   return { anthropicServer, openaiServer };
 }
 function stopProxy(config) {