fix(daemon-server): await express listen() so port is bound before startup completes

`webuiExpressApp.listen(port)` was fire-and-forget — no await on 'listening',
no 'error' handler. Under load `startDaemonServer` could return (and the
daemon could log "Communities in data path") before the OS had finished
binding the RPC port, and a bind failure showed up later as an
uncaughtException that crashed the daemon *after* it had already advertised
itself as ready. The webui suite's first fetch sometimes hit the open window
and failed with ECONNREFUSED.

Wrap listen() in a promise that resolves on 'listening' and rejects on
'error'. Adds a unit test that pre-binds the port and asserts the function
rejects with EADDRINUSE.

Fixes issue #42.

Author: Rinse12

src/webui/daemon-server.ts

@@ -46,7 +46,23 @@ export async function startDaemonServer(rpcUrl: URL, ipfsGatewayUrl: URL, pkcOpt
     // Start pkc-js RPC
     const log = PKCLogger("bitsocial-cli:daemon:startDaemonServer");
     const webuiExpressApp = express();
-    const httpServer = webuiExpressApp.listen(Number(rpcUrl.port));
+    // Wait for bind to actually complete before returning. Calling express.listen() without
+    // awaiting 'listening' lets startup proceed before the port is accepting connections,
+    // and without an 'error' handler a bind failure becomes an uncaughtException that kills
+    // the daemon *after* it has already logged "Communities in data path" — see issue #42.
+    const httpServer = await new Promise<import("http").Server>((resolve, reject) => {
+        const server = webuiExpressApp.listen(Number(rpcUrl.port));
+        const onListening = () => {
+            server.off("error", onError);
+            resolve(server);
+        };
+        const onError = (err: Error) => {
+            server.off("listening", onListening);
+            reject(err);
+        };
+        server.once("listening", onListening);
+        server.once("error", onError);
+    });
     log("HTTP server is running on", "0.0.0.0" + ":" + rpcUrl.port);
     const rpcAuthKey = await _generateRpcAuthKeyIfNotExisting(pkcOptions.dataPath!);
     const PKCRpc = await import("@pkcprotocol/pkc-js/rpc");

test/webui/daemon-server.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import net from "net";
+import { directory as randomDirectory } from "tempy";
+import { startDaemonServer } from "../../dist/webui/daemon-server.js";
+
+// Regression test for issue #42:
+// startDaemonServer used to call webuiExpressApp.listen(port) fire-and-forget — no
+// await on 'listening', no 'error' handler. If bind failed, the promise still resolved
+// and the bind error showed up later as an uncaughtException, crashing the daemon
+// AFTER the test helper had already accepted "Communities in data path" as readiness.
+// The contract we want: if the port can't be bound, startDaemonServer must reject.
+describe("startDaemonServer bind contract", () => {
+    it("rejects when the RPC port is already taken (regression for issue #42)", async () => {
+        const blocker = net.createServer();
+        const port = await new Promise<number>((resolve, reject) => {
+            blocker.once("listening", () => {
+                const addr = blocker.address();
+                if (addr && typeof addr === "object") resolve(addr.port);
+                else reject(new Error(`unexpected address ${JSON.stringify(addr)}`));
+            });
+            blocker.once("error", reject);
+            blocker.listen(0, "127.0.0.1");
+        });
+
+        // Swallow any stray uncaughtException emitted by an unguarded server.listen()
+        // so the test process survives long enough to assert the actual behavior.
+        const stray: Error[] = [];
+        const uncaughtHandler = (err: Error) => stray.push(err);
+        process.on("uncaughtException", uncaughtHandler);
+
+        try {
+            await expect(
+                startDaemonServer(
+                    new URL(`ws://127.0.0.1:${port}`),
+                    new URL("http://127.0.0.1:6754"),
+                    { dataPath: randomDirectory() }
+                )
+            ).rejects.toThrow(/EADDRINUSE|address already in use/i);
+            // And no stray uncaughtException either — the bind error must come back
+            // through the promise, not the process.
+            expect(stray).toEqual([]);
+        } finally {
+            process.off("uncaughtException", uncaughtHandler);
+            await new Promise<void>((resolve) => blocker.close(() => resolve()));
+        }
+    });
+});