[autofix.ci] apply automated fixes

This commit adds basic support for the HTTP CONNECT method in node:http server:
- Modified uWebSockets parser to accept CONNECT request URLs (host:port format)
- Added 'connect' event emission in the HTTP server
- Created tests to verify the functionality

Note: This is a partial implementation with known limitations around raw socket handling.

Fixes #16372

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>

packages/bun-uws/src/HttpParser.h

@@ -551,7 +551,8 @@ namespace uWS
                 return ConsumeRequestLineResult::shortRead();
             }
 
-            if (data[0] == 32 && (__builtin_expect(data[1] == '/', 1) || isHTTPorHTTPSPrefixForProxies(data + 1, end) == 1)) [[likely]] {
+            if (data[0] == 32 && (__builtin_expect(data[1] == '/', 1) || isHTTPorHTTPSPrefixForProxies(data + 1, end) == 1 || 
+                    ((data - start) == 7 && memcmp(start, "CONNECT", 7) == 0))) [[likely]] {
                 header.key = {start, (size_t) (data - start)};
                 data++;
                 if(!isValidMethod(header.key, useStrictMethodValidation)) {

src/js/node/_http_server.ts

@@ -588,6 +588,19 @@ Server.prototype[kRealListen] = function (tls, port, host, socketPath, reusePort
               http_res.assignSocket(socket);
             }
           }
+        } else if (method === "CONNECT") {
+          // Handle CONNECT method for HTTP tunneling/proxy
+          if (server.listenerCount("connect") > 0) {
+            // For CONNECT, emit the event and let the handler respond
+            server.emit("connect", http_req, socket, kEmptyBuffer);
+
+            // Don't assign the socket to a response for CONNECT
+            // The handler should write the raw response
+          } else {
+            // If no connect handler, respond with 400 Bad Request
+            http_res.writeHead(400);
+            http_res.end();
+          }
         } else if (http_req.headers.expect !== undefined) {
           if (http_req.headers.expect === "100-continue") {
             if (server.listenerCount("checkContinue") > 0) {
@@ -998,7 +1011,26 @@ const NodeHTTPServerSocket = class Socket extends Duplex {
     return this;
   }
 
-  _write(_chunk, _encoding, _callback) {}
+  _write(chunk, encoding, callback) {
+    // For CONNECT tunneling, we need to write raw data
+    const handle = this[kHandle];
+    if (handle && handle.write) {
+      // Try to write directly to the socket handle
+      try {
+        // Convert string to buffer if needed
+        if (typeof chunk === "string") {
+          chunk = Buffer.from(chunk, encoding || "utf8");
+        }
+        // Write raw data
+        handle.write(chunk);
+        if (callback) callback();
+      } catch (err) {
+        if (callback) callback(err);
+      }
+    } else {
+      if (callback) callback(new Error("Socket not writable"));
+    }
+  }
 
   pause() {
     const handle = this[kHandle];

test/regression/issue/16372-http-connect-event-minimal.test.ts

@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test";
+import { createServer } from "node:http";
+import net from "node:net";
+
+test("node:http server emits 'connect' event for CONNECT method", async () => {
+  let connectEventEmitted = false;
+  let receivedRequest = null;
+
+  const server = createServer();
+
+  server.on("connect", (req, socket, head) => {
+    connectEventEmitted = true;
+    receivedRequest = {
+      method: req.method,
+      url: req.url,
+    };
+    // Note: Raw socket writing is not fully implemented yet
+    // This test only verifies the event is emitted
+    socket.end();
+  });
+
+  await new Promise<void>(resolve => {
+    server.listen(0, "127.0.0.1", () => {
+      resolve();
+    });
+  });
+
+  const port = (server.address() as any).port;
+
+  // Send CONNECT request
+  const client = net.createConnection({ port, host: "127.0.0.1" }, () => {
+    client.write("CONNECT github.com:443 HTTP/1.1\r\n");
+    client.write("Host: github.com:443\r\n");
+    client.write("\r\n");
+  });
+
+  await new Promise<void>(resolve => {
+    client.on("end", () => {
+      resolve();
+    });
+    client.on("error", () => {
+      resolve();
+    });
+
+    // Timeout to prevent hanging
+    setTimeout(() => {
+      client.destroy();
+      resolve();
+    }, 1000);
+  });
+
+  // Verify the connect event was emitted with correct data
+  expect(connectEventEmitted).toBe(true);
+  expect(receivedRequest).not.toBeNull();
+  expect(receivedRequest?.method).toBe("CONNECT");
+  expect(receivedRequest?.url).toBe("github.com:443");
+
+  server.close();
+  client.destroy();
+});

test/regression/issue/16372-http-connect-event.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from "bun:test";
+import { createServer } from "node:http";
+import net from "node:net";
+
+test("node:http server should emit 'connect' event for CONNECT method", async () => {
+  let connectCalled = false;
+
+  const server = createServer();
+
+  server.on("connect", (req, socket, head) => {
+    connectCalled = true;
+    // Respond with 200 Connection Established
+    socket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+    socket.end();
+  });
+
+  await new Promise<void>(resolve => {
+    server.listen(0, "127.0.0.1", () => {
+      resolve();
+    });
+  });
+
+  const port = (server.address() as any).port;
+
+  // Create a client connection and send CONNECT request
+  const client = net.createConnection({ port, host: "127.0.0.1" }, () => {
+    client.write("CONNECT github.com:443 HTTP/1.1\r\n");
+    client.write("Host: github.com:443\r\n");
+    client.write("Proxy-Connection: Keep-Alive\r\n");
+    client.write("\r\n");
+  });
+
+  let response = "";
+  client.on("data", data => {
+    response += data.toString();
+  });
+
+  await new Promise<void>(resolve => {
+    client.on("end", () => {
+      resolve();
+    });
+  });
+
+  // Verify the connect event was called
+  expect(connectCalled).toBe(true);
+
+  // Verify proper response
+  expect(response).toContain("200 Connection Established");
+
+  server.close();
+  client.destroy();
+});
+
+test("node:http server should respond with 400 if no connect handler", async () => {
+  const server = createServer();
+
+  // No connect event handler - should return 400
+
+  await new Promise<void>(resolve => {
+    server.listen(0, "127.0.0.1", () => {
+      resolve();
+    });
+  });
+
+  const port = (server.address() as any).port;
+
+  // Create a client connection and send CONNECT request
+  const client = net.createConnection({ port, host: "127.0.0.1" }, () => {
+    client.write("CONNECT github.com:443 HTTP/1.1\r\n");
+    client.write("Host: github.com:443\r\n");
+    client.write("\r\n");
+  });
+
+  let response = "";
+  client.on("data", data => {
+    response += data.toString();
+  });
+
+  await new Promise<void>(resolve => {
+    client.on("end", () => {
+      resolve();
+    });
+    client.on("error", () => {
+      // Connection might be closed early
+      resolve();
+    });
+  });
+
+  // Should get 400 or 405 response
+  expect(response).toMatch(/HTTP\/1\.1 (400|405)/);
+
+  server.close();
+  client.destroy();
+});