Bun.serve: throw when both port and unix are given

src/js/node/_http_server.ts

@@ -548,6 +548,10 @@ Server.prototype.listen = function () {
       port = arg0.port;
       host = arg0.host;
       socketPath = arg0.path;
+      // Node normalizes an explicit `port: undefined` or `port: null` to 0.
+      if ((port === undefined && "port" in arg0) || port === null) {
+        port = 0;
+      }
 
       const otherTLS = arg0.tls;
       if (otherTLS && $isObject(otherTLS)) {
@@ -578,6 +582,13 @@ Server.prototype.listen = function () {
     }
   }
 
+  // Node precedence: a port wins over `path`, and a `path` listen ignores `host`.
+  if ((typeof port === "number" || typeof port === "string") && socketPath) {
+    socketPath = undefined;
+  } else if (socketPath) {
+    host = undefined;
+  }
+
   const lastArg = arguments[argc - 1];
   if ($isCallable(lastArg)) {
     // Before the bind, as in node, so a listen() retried from the 'error' handler still calls it.

src/runtime/server/ServerConfig.rs

@@ -635,6 +635,7 @@ impl ServerConfig {
             ..ServerConfig::default()
         };
         let mut has_hostname = false;
+        let mut has_port = false;
 
         if env.get(b"NODE_ENV").unwrap_or(b"") == b"production" {
             args.development = DevelopmentOption::Production;
@@ -1083,6 +1084,7 @@ impl ServerConfig {
                 *tp = p;
             }
             port = p;
+            has_port = p != 0;
         }
 
         if let Some(base_uri) = arg.get_truthy(global, "baseURI")? {
@@ -1120,6 +1122,11 @@ impl ServerConfig {
                         "Cannot specify both hostname and unix",
                     )));
                 }
+                if has_port {
+                    return Err(global.throw_invalid_arguments(format_args!(
+                        "Cannot specify both port and unix",
+                    )));
+                }
 
                 args.address = Address::Unix(bun_core::ZBox::from_bytes(unix_str.slice()));
             }

test/js/bun/http/serve.test.ts

@@ -1,6 +1,6 @@
 import { file, gc, Serve, serve, Server } from "bun";
 import { afterAll, afterEach, describe, expect, it, mock } from "bun:test";
-import { readFileSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import {
   bunEnv,
   bunExe,
@@ -2493,6 +2493,33 @@ it("unix socket connection throws an error on a bad domain without crashing", as
   }).toThrow();
 });
 
+it("Bun.serve throws when both port and unix are given", async () => {
+  using dir = tempDir("port-and-unix", {});
+  const unix = join(String(dir), "port-and-unix.sock");
+  expect(() => {
+    using server = Bun.serve({
+      port: 1,
+      unix,
+      fetch() {
+        return new Response("hey");
+      },
+    });
+  }).toThrow("Cannot specify both port and unix");
+  expect(existsSync(unix)).toBe(false);
+
+  // port 0 asks for no specific port, so it does not conflict with unix.
+  using server = Bun.serve({
+    port: 0,
+    unix,
+    fetch() {
+      return new Response("hey");
+    },
+  });
+  expect(server.port).toBeUndefined();
+  const res = await fetch("http://localhost/", { unix });
+  expect(await res.text()).toBe("hey");
+});
+
 it("#5859 text", async () => {
   using server = Bun.serve({
     port: 0,

test/js/node/http/node-http.test.ts

@@ -1338,6 +1338,35 @@ describe("node:http", () => {
     await promise;
   });
 
+  // Node binds the TCP port and ignores `path` whenever the options carry a
+  // `port` key, including `port: undefined`, `port: null` and a string port.
+  test.each([0, "0", undefined, null])("listen({ port: %p, path }) binds the port and ignores the path", async port => {
+    const socketPath = `${tmpdir()}/bun-server-${Math.random().toString(32)}.sock`;
+    await using server = createServer((req, res) => {
+      res.end("ok");
+    });
+    server.listen({ port, path: socketPath });
+    await once(server, "listening");
+    const address = server.address() as AddressInfo;
+    expect(typeof address).toBe("object");
+    expect(address.port).toBeGreaterThan(0);
+    expect(nodefs.existsSync(socketPath)).toBe(false);
+    const response = await fetch(`http://127.0.0.1:${address.port}/`);
+    expect(await response.text()).toBe("ok");
+  });
+
+  test("listen({ path, host }) binds the path and ignores the host, as in node", async () => {
+    const socketPath = `${tmpdir()}/bun-server-${Math.random().toString(32)}.sock`;
+    await using server = createServer((req, res) => {
+      res.end("ok");
+    });
+    server.listen({ path: socketPath, host: "localhost" });
+    await once(server, "listening");
+    expect(server.address()).toBe(socketPath);
+    const response = await fetch("http://localhost/", { unix: socketPath });
+    expect(await response.text()).toBe("ok");
+  });
+
   test("should not decompress gzip, issue#4397", async () => {
     using server = Bun.serve({
       port: 0,