test(kubo): pre-init repos with ephemeral swarm so parallel tests don't collide on 4001

Before this branch, mergeCliDefaultsIntoIpfsConfig overrode Swarm to /tcp/0
which (incidentally) gave each test daemon a kernel-assigned port. Now that
production preserves kubo's default Swarm (port 4001), parallel test
daemons spawned by vitest fileParallelism race for the same port and fail
with "IPFS Swarm port 0.0.0.0:4001 already in use".

Add a test helper that pre-initializes the kubo repo, applies bitsocial
defaults, and rewrites Swarm to ephemeral addresses. The daemon's own
`ipfs init` then bails because the config already exists, mergeCliDefaults
is skipped, and kubo binds to per-process kernel-assigned ports.

Refs #44

Author: Rinse12

test/helpers/daemon-helpers.ts

@@ -1,8 +1,10 @@
 import { ChildProcess, spawn } from "child_process";
 import net from "net";
+import path from "path";
 import { directory as randomDirectory } from "tempy";
 import WebSocket from "ws";
 import defaults from "../../dist/common-utils/defaults.js";
+import { preInitKuboWithEphemeralSwarm } from "./kubo-helpers.js";
 
 export type ManagedChildProcess = ChildProcess & { kuboRpcUrl?: URL; capturedStdout?: string; capturedStderr?: string };
 
@@ -72,7 +74,20 @@ export const startPkcDaemon = (args: string[], env?: Record<string, string>): Pr
         const hasCustomDataPath = args.some((arg) => arg.startsWith("--pkcOptions.dataPath"));
         const hasCustomLogPath = args.some((arg) => arg === "--logPath");
         const logPathArgs = hasCustomLogPath ? [] : ["--logPath", randomDirectory()];
-        const daemonArgs = hasCustomDataPath ? args : ["--pkcOptions.dataPath", randomDirectory(), ...args];
+        const dataPath = hasCustomDataPath
+            ? (args[args.findIndex((a) => a.startsWith("--pkcOptions.dataPath")) + 1] as string)
+            : randomDirectory();
+        const daemonArgs = hasCustomDataPath ? args : ["--pkcOptions.dataPath", dataPath, ...args];
+
+        // Pre-init kubo so parallel test daemons don't collide on swarm port 4001.
+        const apiUrl = new URL(env?.KUBO_RPC_URL ?? defaults.KUBO_RPC_URL.toString());
+        const gatewayUrl = new URL(env?.IPFS_GATEWAY_URL ?? defaults.IPFS_GATEWAY_URL.toString());
+        try {
+            await preInitKuboWithEphemeralSwarm(path.join(dataPath, ".bitsocial-cli.ipfs"), apiUrl, gatewayUrl);
+        } catch (error) {
+            return reject(error);
+        }
+
         const daemonProcess = spawn("node", ["./bin/run", "daemon", ...logPathArgs, ...daemonArgs], {
             stdio: ["pipe", "pipe", "pipe"],
             env: env ? { ...process.env, ...env } : undefined

test/helpers/kubo-helpers.ts

@@ -0,0 +1,39 @@
+import * as fs from "fs/promises";
+import path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { path as resolveKuboBinary } from "kubo";
+import { mergeCliDefaultsIntoIpfsConfig } from "../../src/ipfs/startIpfs.js";
+
+const execFileAsync = promisify(execFile);
+
+const EPHEMERAL_SWARM_ADDRESSES = [
+    "/ip4/0.0.0.0/tcp/0",
+    "/ip6/::/tcp/0",
+    "/ip4/0.0.0.0/udp/0/quic-v1",
+    "/ip4/0.0.0.0/udp/0/quic-v1/webtransport",
+    "/ip6/::/udp/0/quic-v1",
+    "/ip6/::/udp/0/quic-v1/webtransport"
+];
+
+// Pre-init a kubo repo so each parallel test daemon gets its own kernel-assigned
+// swarm port instead of fighting over the default 4001. Mirrors what
+// startKuboNode does on a fresh config (init + server profile + merge defaults),
+// then overrides Swarm to ephemeral addresses. When the bitsocial daemon later
+// runs `ipfs init` against this dir it'll bail with "configuration file already
+// exists", skip mergeCliDefaultsIntoIpfsConfig, and spawn kubo with our Swarm.
+export const preInitKuboWithEphemeralSwarm = async (ipfsDataPath: string, apiUrl: URL, gatewayUrl: URL) => {
+    await fs.mkdir(ipfsDataPath, { recursive: true });
+    const kuboBinaryPath = await resolveKuboBinary();
+    const env = { ...process.env, IPFS_PATH: ipfsDataPath };
+
+    await execFileAsync(kuboBinaryPath, ["init"], { env });
+    await execFileAsync(kuboBinaryPath, ["config", "profile", "apply", "server"], { env });
+
+    const configPath = path.join(ipfsDataPath, "config");
+    await mergeCliDefaultsIntoIpfsConfig(() => {}, configPath, apiUrl, gatewayUrl);
+
+    const config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+    config.Addresses = { ...(config.Addresses ?? {}), Swarm: EPHEMERAL_SWARM_ADDRESSES };
+    await fs.writeFile(configPath, JSON.stringify(config, null, 4));
+};

test/kubo/kuboRpcGateway.integration.test.ts

@@ -9,6 +9,7 @@ import { directory as tempDirectory } from "tempy";
 import { setTimeout as delay } from "timers/promises";
 import { promisify } from "util";
 import { startKuboNode } from "../../src/ipfs/startIpfs.js";
+import { preInitKuboWithEphemeralSwarm } from "../helpers/kubo-helpers.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -184,6 +185,8 @@ describe("kubo RPC + gateway integration", { timeout: 120_000 }, () => {
         apiUrl = new URL(`http://127.0.0.1:${apiPort}`);
         gatewayUrl = new URL(`http://127.0.0.1:${gatewayPort}`);
 
+        await preInitKuboWithEphemeralSwarm(ipfsRepoPath, apiUrl, gatewayUrl);
+
         kuboProcess = await startKuboNode(apiUrl, gatewayUrl, dataPath);
 
         await waitForOkResponse(() => fetch(new URL("/api/v0/version", apiUrl), { method: "POST" }));