@bman654/clodex 2.11.2 → 2.11.3

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.11.2",
+  version: "2.11.3",
   publishConfig: {
     access: "public"
   },
@@ -18389,6 +18389,7 @@ import * as p9 from "@clack/prompts";
 import * as http2 from "http";
 import * as https from "https";
 import * as net from "net";
+import { PassThrough } from "stream";
 import { randomUUID as randomUUID6 } from "crypto";
 import { URL as URL2 } from "url";
 import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
@@ -19076,6 +19077,97 @@ function forwardToAdapter(req, res, rawBody, adapter, adapterRequest = http2.req
     upstream.end(rawBody);
   });
 }
+function forwardAnthropicUpgrade(req, clientSocket, head, origin, rejectUnauthorized, agent, sockets) {
+  if (clientSocket._httpMessage) {
+    clientSocket.destroy();
+    return;
+  }
+  const clientData = new PassThrough();
+  clientSocket.pipe(clientData);
+  let responseStarted = false;
+  let upgradedSocket;
+  const upstream = https.request({
+    protocol: "https:",
+    hostname: origin.hostname,
+    port: origin.port || 443,
+    method: req.method,
+    path: req.url,
+    headers: requestHeadersWithoutProxyHeaders(req),
+    servername: net.isIP(origin.hostname) ? void 0 : origin.hostname,
+    rejectUnauthorized,
+    agent
+  });
+  const fail = () => {
+    if (clientSocket.destroyed) return;
+    if (responseStarted) {
+      clientSocket.destroy();
+      return;
+    }
+    responseStarted = true;
+    clientSocket.end(
+      "HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+      () => clientSocket.destroy()
+    );
+  };
+  clientSocket.once("error", () => clientSocket.destroy());
+  clientSocket.once("end", () => {
+    if (!responseStarted) clientSocket.destroy();
+  });
+  clientSocket.once("close", () => {
+    clientData.destroy();
+    upstream.destroy();
+    upgradedSocket?.destroy();
+  });
+  upstream.once("socket", (socket) => {
+    if (clientSocket.destroyed) socket.destroy();
+  });
+  upstream.once("error", fail);
+  upstream.once("close", () => {
+    if (!responseStarted) fail();
+  });
+  upstream.once("response", (upstreamRes) => {
+    if (clientSocket.destroyed) {
+      upstreamRes.destroy();
+      return;
+    }
+    responseStarted = true;
+    const response = new http2.ServerResponse(req);
+    response.shouldKeepAlive = false;
+    response.assignSocket(clientSocket);
+    clientSocket.on("drain", () => response.emit("drain"));
+    response.once("error", () => clientSocket.destroy());
+    response.once("finish", () => clientSocket.end(() => clientSocket.destroy()));
+    copyResponse(upstreamRes, response);
+  });
+  upstream.once("upgrade", (upstreamRes, socket, upstreamHead) => {
+    if (clientSocket.destroyed) {
+      socket.destroy();
+      return;
+    }
+    responseStarted = true;
+    upgradedSocket = socket;
+    sockets.add(socket);
+    socket.once("error", () => clientSocket.destroy());
+    socket.once("close", () => {
+      sockets.delete(socket);
+      clientSocket.destroy();
+    });
+    const headers = [
+      `HTTP/${upstreamRes.httpVersion} ${upstreamRes.statusCode} ${upstreamRes.statusMessage}`
+    ];
+    for (let i = 0; i < upstreamRes.rawHeaders.length; i += 2) {
+      headers.push(`${upstreamRes.rawHeaders[i]}: ${upstreamRes.rawHeaders[i + 1]}`);
+    }
+    clientSocket.write(Buffer.from(`${headers.join("\r\n")}\r
+\r
+`, "latin1"));
+    if (upstreamHead.length > 0) clientSocket.write(upstreamHead);
+    if (head.length > 0) socket.write(head);
+    clientData.pipe(socket);
+    socket.pipe(clientSocket);
+  });
+  upstream.end();
+}
 function forwardPlainHttp(req, res) {
   let target;
   try {
@@ -19292,6 +19384,17 @@ async function startHttpProxy(options) {
     );
   });
   const sockets = /* @__PURE__ */ new Set();
+  mitmServer.on("upgrade", (req, socket, head) => {
+    forwardAnthropicUpgrade(
+      req,
+      socket,
+      head,
+      anthropicOrigin,
+      options.anthropicRejectUnauthorized ?? true,
+      anthropicAgent,
+      sockets
+    );
+  });
   const proxyServer = http2.createServer(forwardPlainHttp);
   proxyServer.on("connection", (socket) => {
     sockets.add(socket);