[autofix.ci] apply automated fixes

- Make callback asynchronous using process.nextTick to match Node.js behavior
- Remove socket.on('close') event listener to avoid performance overhead
- Use existing #onClose method in NodeHTTPServerSocket for connection cleanup
- Update regression tests to handle async callback behavior

Performance improvements:
- Eliminates adding/removing event listeners for each connection
- Uses existing socket cleanup mechanism instead of adding new listeners
- Callback now properly async via process.nextTick like Node.js

All tests pass and behavior matches Node.js exactly.

🤖 Generated with [Claude Code](https://claude.ai/code)

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

src/js/node/_http_server.ts

@@ -204,6 +204,7 @@ function Server(options, callback): void {
   this[kInternalSocketData] = undefined;
   this[tlsSymbol] = null;
   this.noDelay = true;
+  this._connections = 0;
   if (typeof options === "function") {
     callback = options;
     options = {};
@@ -361,6 +362,18 @@ Server.prototype.address = function () {
   return this[serverSymbol].address;
 };
 
+Server.prototype.getConnections = function (callback) {
+  if (typeof callback === "function") {
+    // In Bun case we will never error on getConnections
+    // Node only errors if in the middle of counting the server got disconnected,
+    // which never happens in Bun
+    // If disconnected will only pass null as well and 0 connected
+    const count = this[serverSymbol] ? this._connections : 0;
+    process.nextTick(callback, null, count);
+  }
+  return this;
+};
+
 Server.prototype.listen = function () {
   const server = this;
   let port, host, onListen;
@@ -552,6 +565,7 @@ Server.prototype[kRealListen] = function (tls, port, host, socketPath, reusePort
         }
 
         if (isSocketNew && !reachedRequestsLimit) {
+          server._connections++;
           server.emit("connection", socket);
         }
 
@@ -820,6 +834,12 @@ const NodeHTTPServerSocket = class Socket extends Duplex {
   }
   #onClose() {
     this[kHandle] = null;
+
+    // Decrement connection count when socket closes
+    if (this.server && this.server._connections > 0) {
+      this.server._connections--;
+    }
+
     const message = this._httpMessage;
     const req = message?.req;
     if (req && !req.complete && !req[kHandle]?.upgraded) {

test/regression/issue/04459.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Regression test for GitHub issue #4459
+ * https://github.com/oven-sh/bun/issues/4459
+ *
+ * Issue: "server.getConnections is not implemented"
+ * Expected: getConnections should work exactly like Node.js
+ */
+
+import { expect, test } from "bun:test";
+import * as http from "http";
+import * as net from "net";
+
+test("issue #4459: server.getConnections should be implemented and work like Node.js", async () => {
+  const server = net.createServer();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+
+  const results: Array<{ err: any; count: number }> = [];
+
+  server.listen(0, () => {
+    const port = server.address()!.port;
+
+    // Test 1: No connections initially
+    server.getConnections((err, count) => {
+      results.push({ err, count });
+
+      // Test 2: Create connection and verify count increases
+      const client1 = net.createConnection(port, () => {
+        setTimeout(() => {
+          server.getConnections((err, count) => {
+            results.push({ err, count });
+
+            // Test 3: Create second connection
+            const client2 = net.createConnection(port, () => {
+              setTimeout(() => {
+                server.getConnections((err, count) => {
+                  results.push({ err, count });
+
+                  // Test 4: Close one connection
+                  client1.end();
+                  setTimeout(() => {
+                    server.getConnections((err, count) => {
+                      results.push({ err, count });
+
+                      // Test 5: Close second connection
+                      client2.end();
+                      setTimeout(() => {
+                        server.getConnections((err, count) => {
+                          results.push({ err, count });
+
+                          server.close();
+                          resolve();
+                        });
+                      }, 50);
+                    });
+                  }, 50);
+                });
+              }, 50);
+            });
+
+            client2.on("error", reject);
+          });
+        }, 50);
+      });
+
+      client1.on("error", reject);
+    });
+  });
+
+  server.on("error", reject);
+
+  await promise;
+
+  // Now we can safely use expect() outside the callbacks
+  expect(results).toHaveLength(5);
+  expect(results[0]).toEqual({ err: null, count: 0 }); // No connections initially
+  expect(results[1]).toEqual({ err: null, count: 1 }); // After client1 connects
+  expect(results[2]).toEqual({ err: null, count: 2 }); // After client2 connects
+  expect(results[3]).toEqual({ err: null, count: 1 }); // After client1 disconnects
+  expect(results[4]).toEqual({ err: null, count: 0 }); // After client2 disconnects
+});
+
+test("issue #4459: getConnections should support method chaining", () => {
+  const server = net.createServer();
+
+  // Method should return the server instance for chaining
+  const result = server.getConnections(() => {});
+  expect(result).toBe(server);
+
+  server.close();
+});
+
+test("issue #4459: getConnections should work when server is not listening", () => {
+  const server = net.createServer();
+  let callbackCalled = false;
+  let callbackErr: any = undefined;
+  let callbackCount: number = -1;
+
+  const callback = (err: any, count: number) => {
+    callbackCalled = true;
+    callbackErr = err;
+    callbackCount = count;
+  };
+
+  // Should call callback with 0 connections when not listening
+  server.getConnections(callback);
+
+  expect(callbackCalled).toBe(true);
+  expect(callbackErr).toBeNull();
+  expect(callbackCount).toBe(0);
+});
+
+test("issue #4459: http.Server.getConnections should be implemented", async () => {
+  const server = http.createServer();
+
+  // Test that the method exists
+  expect(typeof server.getConnections).toBe("function");
+
+  // Test basic functionality - should return 0 when not listening (async)
+  const { promise, resolve } = Promise.withResolvers<{ err: any; count: number }>();
+
+  const callback = (err: any, count: number) => {
+    resolve({ err, count });
+  };
+
+  server.getConnections(callback);
+
+  const result = await promise;
+  expect(result.err).toBeNull();
+  expect(result.count).toBe(0);
+
+  server.close();
+});
+
+test("issue #4459: http.Server.getConnections should support method chaining", () => {
+  const server = http.createServer();
+
+  // Method should return the server instance for chaining
+  const result = server.getConnections(() => {});
+  expect(result).toBe(server);
+
+  server.close();
+});
+
+test("issue #4459: http.Server.getConnections should work when server is not listening", async () => {
+  const server = http.createServer();
+
+  // Should call callback with 0 connections when not listening (async)
+  const { promise, resolve } = Promise.withResolvers<{ err: any; count: number }>();
+
+  const callback = (err: any, count: number) => {
+    resolve({ err, count });
+  };
+
+  server.getConnections(callback);
+
+  const result = await promise;
+  expect(result.err).toBeNull();
+  expect(result.count).toBe(0);
+});