fix(ipfs): listen on 'close' so stderr drains before _spawnAsync rejects

Pulled the Promise wiring out of _spawnAsync into an exported
_gatherChildOutput so the race is unit-testable. Listen on 'close' (not
'exit'): Node guarantees 'close' fires after all stdio streams have
closed, so every stderr 'data' event has been delivered by the time we
build the rejection Error.

Why this matters: a fast-exiting child can deliver its exit signal
before its stderr drains. With the old 'exit' listener, _spawnAsync
rejected with errorMessage="". In startKuboNode the empty message
defeated the `error.message.includes("ipfs configuration file already
exists!")` suppression, turned a benign already-initialised repo into
"Failed to call ipfs init" — and because startKuboNode wraps an async
executor in `new Promise(...)`, that throw became an unhandledRejection
instead of propagating, hanging keepKuboUp() and letting the daemon
exit silently with code 0. That's the macos-latest CI failure on PR #47.

The regression test in test/kubo/gather-child-output.test.ts feeds a
fake EventEmitter the macOS event ordering (exit → data → close) and
asserts the rejection captures the stderr text. Cross-platform
deterministic, fails on the old 'exit' listener, passes on 'close'.

Author: Rinse12

src/ipfs/startIpfs.ts

@@ -75,32 +75,38 @@ export async function mergeCliDefaultsIntoIpfsConfig(log: any, ipfsConfigPath: s
 // use this custom function instead of spawnSync for better logging
 // also spawnSync might have been causing crash on start on windows
 
-function _spawnAsync(log: any, ...args: any[]) {
+// Listens on 'close' (not 'exit') so all stderr 'data' events have been delivered
+// before we read errorMessage — otherwise on macOS a fast-exiting child can deliver
+// its exit signal before its stderr drains, producing a rejection with an empty
+// message and breaking the "configuration file already exists" suppression upstream.
+export function _gatherChildOutput(log: any, child: ChildProcessWithoutNullStreams): Promise<null> {
     return new Promise((resolve, reject) => {
-        //@ts-ignore
-        const spawedProcess: ChildProcessWithoutNullStreams = spawn(...args);
         let errorMessage = "";
-        spawedProcess.on("exit", (exitCode, signal) => {
-            if (exitCode === 0) resolve(null);
-            else {
-                const error = new Error(errorMessage);
-                Object.assign(error, { exitCode, pid: spawedProcess.pid, signal });
-                reject(error);
-            }
+        child.on("close", (exitCode, signal) => {
+            if (exitCode === 0) return resolve(null);
+            const error = new Error(errorMessage);
+            Object.assign(error, { exitCode, pid: child.pid, signal });
+            reject(error);
         });
-        spawedProcess.stderr.on("data", (data) => {
+        child.stderr.on("data", (data) => {
             log.trace(data.toString());
             errorMessage += data.toString();
         });
-        spawedProcess.stdin.on("data", (data) => log.trace(data.toString()));
-        spawedProcess.stdout.on("data", (data) => log.trace(data.toString()));
-        spawedProcess.on("error", (data) => {
+        child.stdin.on("data", (data) => log.trace(data.toString()));
+        child.stdout.on("data", (data) => log.trace(data.toString()));
+        child.on("error", (data) => {
             errorMessage += data.toString();
             log.error(data.toString());
         });
     });
 }
 
+function _spawnAsync(log: any, ...args: any[]) {
+    //@ts-ignore
+    const child: ChildProcessWithoutNullStreams = spawn(...args);
+    return _gatherChildOutput(log, child);
+}
+
 type MultiaddrComponent = { name: string; value?: string };
 type MultiaddrModule = {
     multiaddr: (multiAddr: string) => {

test/kubo/gather-child-output.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { EventEmitter } from "node:events";
+import { _gatherChildOutput } from "../../dist/ipfs/startIpfs.js";
+
+const noopLog = Object.assign(() => {}, { trace: () => {}, error: () => {} });
+
+const makeFakeChild = () =>
+    Object.assign(new EventEmitter(), {
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        stdin: new EventEmitter(),
+        pid: 12345
+    }) as any;
+
+describe("_gatherChildOutput", () => {
+    it("captures stderr even when the child's 'exit' event fires before stderr 'data' (macOS race)", async () => {
+        const child = makeFakeChild();
+        const promise = _gatherChildOutput(noopLog, child);
+
+        // Simulate the macOS-style ordering: process exits first, stderr drains
+        // afterwards, 'close' fires last. The previous 'exit'-based listener would
+        // settle the promise with an empty errorMessage at the first emit and miss
+        // the stderr payload entirely.
+        queueMicrotask(() => {
+            child.emit("exit", 1, null);
+            setImmediate(() => {
+                child.stderr.emit("data", Buffer.from("Error: ipfs configuration file already exists!\n"));
+                child.emit("close", 1, null);
+            });
+        });
+
+        await expect(promise).rejects.toThrow(/ipfs configuration file already exists!/);
+    });
+
+    it("resolves cleanly when the child exits with code 0", async () => {
+        const child = makeFakeChild();
+        const promise = _gatherChildOutput(noopLog, child);
+        queueMicrotask(() => child.emit("close", 0, null));
+        await expect(promise).resolves.toBeNull();
+    });
+});