@bitsocial/bitsocial-cli 0.19.65 → 0.19.67

package/dist/cli/commands/daemon.js

@@ -6,10 +6,10 @@ import tcpPortUsed from "tcp-port-used";
 import { getLanIpV4Address, PKCLogger, setupDebugLogger, loadKuboConfigFile, parseMultiAddrKuboRpcToUrl, parseMultiAddrIpfsGatewayToUrl } from "../../util.js";
 import { startDaemonServer } from "../../webui/daemon-server.js";
 import { printBanner } from "../ascii-banner.js";
-import { loadChallengesIntoPKC } from "../../challenge-packages/challenge-utils.js";
+import { loadChallengesIntoPKC, formatChallengeNameVersion } from "../../challenge-packages/challenge-utils.js";
 import { migrateDataDirectory } from "../../common-utils/data-migration.js";
 import { createBsoResolvers, DEFAULT_PROVIDERS } from "../../common-utils/resolvers.js";
-import { pruneStaleStates, writeDaemonState, deleteDaemonState } from "../../common-utils/daemon-state.js";
+import { pruneStaleStates, writeDaemonState, deleteDaemonState, DAEMON_SHUTDOWN_TIMEOUT_MS } from "../../common-utils/daemon-state.js";
 import { createDaemonFileLogger } from "../../common-utils/daemon-file-logger.js";
 import fs from "fs";
 import fsPromise from "fs/promises";
@@ -275,7 +275,10 @@ export default class Daemon extends Command {
             let pendingKuboStart;
             // Kubo Node may fail randomly, we need to set a listener so when it exits because of an error we restart it
             let kuboProcess;
-            const keepKuboUp = async () => {
+            // Every kubo we've spawned that hasn't exited yet. Exit cleanup kills all of these,
+            // so a kubo that slipped out of kuboProcess tracking still dies with the daemon (issue #70)
+            const liveKuboPids = new Set();
+            const keepKuboUpOnce = async () => {
                 if (mainProcessExited)
                     return;
                 const kuboApiPort = Number(kuboRpcEndpoint.port);
@@ -283,6 +286,17 @@ export default class Daemon extends Command {
                     return; // already started, no need to intervene
                 const connectHostname = toConnectableHostname(kuboRpcEndpoint.hostname);
                 const isKuboApiPortTaken = await tcpPortUsed.check(kuboApiPort, connectHostname);
+                // Test hook: widens the window between the re-entrancy guard above and the pendingKuboStart
+                // assignment below, so tests can deterministically reproduce concurrent keepKuboUp entries
+                // (issue #70, see test/cli/daemon-kubo-restart-race.test.ts)
+                const portCheckDelayRaw = process.env["PKC_CLI_TEST_KEEPKUBOUP_PORTCHECK_DELAY_MS"];
+                const portCheckDelay = portCheckDelayRaw ? Number(portCheckDelayRaw) : 0;
+                if (Number.isFinite(portCheckDelay) && portCheckDelay > 0)
+                    await new Promise((resolve) => setTimeout(resolve, portCheckDelay));
+                // Re-check after the awaits above: the daemon may have begun shutting down, or another
+                // kubo may have been adopted in the meantime — spawning now would race it (issue #70)
+                if (mainProcessExited || kuboProcess || pendingKuboStart)
+                    return;
                 if (isKuboApiPortTaken) {
                     const connectableEndpoint = new URL(kuboRpcEndpoint.toString());
                     connectableEndpoint.hostname = connectHostname;
@@ -306,8 +320,15 @@ export default class Daemon extends Command {
                     }
                     throw new Error(`Cannot start IPFS daemon because the IPFS API port ${kuboRpcEndpoint.hostname}:${kuboApiPort} (configured as ${kuboRpcEndpoint.toString()}) is already in use.`);
                 }
+                let spawnedProcess;
                 const startPromise = startKuboNode(kuboRpcEndpoint, ipfsGatewayEndpoint, mergedPkcOptions.dataPath, (process) => {
+                    spawnedProcess = process;
                     kuboProcess = process;
+                    if (process.pid) {
+                        const pid = process.pid;
+                        liveKuboPids.add(pid);
+                        process.once("exit", () => liveKuboPids.delete(pid));
+                    }
                 });
                 pendingKuboStart = startPromise;
                 let startedProcess;
@@ -315,12 +336,15 @@ export default class Daemon extends Command {
                     startedProcess = await startPromise;
                 }
                 catch (error) {
-                    pendingKuboStart = undefined;
-                    if (!mainProcessExited)
+                    // Only clear state this attempt owns — it may track another attempt's healthy kubo (issue #70)
+                    if (pendingKuboStart === startPromise)
+                        pendingKuboStart = undefined;
+                    if (!mainProcessExited && spawnedProcess && kuboProcess === spawnedProcess)
                         kuboProcess = undefined;
                     throw error;
                 }
-                pendingKuboStart = undefined;
+                if (pendingKuboStart === startPromise)
+                    pendingKuboStart = undefined;
                 if (mainProcessExited) {
                     if (startedProcess?.pid && !startedProcess.killed) {
                         // Race condition: Kubo finished starting after mainProcessExited.
@@ -341,7 +365,8 @@ export default class Daemon extends Command {
                             /* best effort */
                         }
                     }
-                    kuboProcess = undefined;
+                    if (kuboProcess === startedProcess)
+                        kuboProcess = undefined;
                     return;
                 }
                 kuboProcess = startedProcess;
@@ -353,7 +378,8 @@ export default class Daemon extends Command {
                     // Restart Kubo process because it failed
                     if (!mainProcessExited) {
                         log(`Kubo node with pid (${currentProcess?.pid}) exited. Will attempt to restart it`);
-                        kuboProcess = undefined;
+                        if (kuboProcess === currentProcess)
+                            kuboProcess = undefined;
                         try {
                             await keepKuboUp();
                         }
@@ -367,6 +393,19 @@ export default class Daemon extends Command {
                 };
                 currentProcess.once("exit", onKuboExit);
             };
+            // Single-flight wrapper: keepKuboUp is invoked from independent places (the kubo exit
+            // handler and the watchdog interval). Concurrent callers must share one attempt —
+            // otherwise both can pass keepKuboUpOnce's re-entrancy guard during its awaits and
+            // spawn two kubo processes whose failure handling corrupts shared state (issue #70)
+            let keepKuboUpInFlight;
+            const keepKuboUp = () => {
+                if (!keepKuboUpInFlight) {
+                    keepKuboUpInFlight = keepKuboUpOnce().finally(() => {
+                        keepKuboUpInFlight = undefined;
+                    });
+                }
+                return keepKuboUpInFlight;
+            };
             let startedOwnRpc = false;
             let daemonServer;
             const createOrConnectRpc = async () => {
@@ -384,7 +423,7 @@ export default class Daemon extends Command {
                 // Load installed challenge packages before starting the RPC server
                 const loadedChallenges = await loadChallengesIntoPKC(mergedPkcOptions.dataPath);
                 if (loadedChallenges.length > 0)
-                    console.log(`Loaded challenge packages: ${loadedChallenges.join(", ")}`);
+                    console.log(`Loaded challenge packages: ${loadedChallenges.map(formatChallengeNameVersion).join(", ")}`);
                 daemonServer = await startDaemonServer(pkcRpcUrl, ipfsGatewayEndpoint, mergedPkcOptions, {
                     allowPrivateKeyExport: flags.allowPrivateKeyExport
                 });
@@ -429,14 +468,29 @@ export default class Daemon extends Command {
                 }
             };
             const killKuboProcess = async () => {
-                if (pendingKuboStart) {
-                    try {
-                        await pendingKuboStart;
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
+                // Test hook (issue #70): hold off the kubo teardown for a fixed delay so a test can
+                // deterministically reproduce the window where the daemon's RPC port is already free
+                // (daemonServer.destroy() runs in parallel) but kubo is still alive and bound. This is
+                // exactly the window `update install` must not restart into — see
+                // test/cli/update-install-restart-race.test.ts. The daemon process stays alive for the
+                // duration because the exit hook awaits killKuboProcess() before exiting.
+                const kuboShutdownDelayRaw = process.env["PKC_CLI_TEST_KUBO_SHUTDOWN_DELAY_MS"];
+                const kuboShutdownDelay = kuboShutdownDelayRaw ? Number(kuboShutdownDelayRaw) : 0;
+                if (Number.isFinite(kuboShutdownDelay) && kuboShutdownDelay > 0)
+                    await new Promise((resolve) => setTimeout(resolve, kuboShutdownDelay));
+                // Wait (bounded) for any in-flight start attempt so we kill the kubo it may still
+                // spawn. Both promises settle on all failure paths (issue #70), but a spawned kubo
+                // that wedges before "Daemon is ready" without exiting keeps them pending — the
+                // bound ensures shutdown still reaches the SIGINT/SIGKILL flow below, which kills
+                // it via kuboProcess (set in onSpawn) or the liveKuboPids sweep (PR #71 review).
+                const inFlightStarts = [keepKuboUpInFlight, pendingKuboStart]
+                    .filter((promise) => promise !== undefined)
+                    .map((promise) => promise.catch(() => { }));
+                if (inFlightStarts.length > 0)
+                    await Promise.race([
+                        Promise.all(inFlightStarts),
+                        new Promise((resolve) => setTimeout(resolve, 15_000).unref())
+                    ]);
                 if (kuboProcess?.pid && !kuboProcess.killed) {
                     const pid = kuboProcess.pid;
                     log("Attempting to kill kubo process with pid", pid);
@@ -466,6 +520,11 @@ export default class Daemon extends Command {
                         kuboProcess = undefined;
                     }
                 }
+                // Defense in depth: SIGKILL any spawned kubo that slipped out of kuboProcess
+                // tracking (e.g. via a state race) so nothing outlives the daemon (issue #70)
+                for (const pid of liveKuboPids)
+                    killKuboProcessGroup(pid, "SIGKILL");
+                liveKuboPids.clear();
             };
             asyncExitHook(async () => {
                 if (keepKuboUpInterval)
@@ -489,16 +548,61 @@ export default class Daemon extends Command {
                         log.error("Error shutting down daemon server", e);
                     }
                 await kuboKillPromise;
-            }, { wait: 120000 } // could take two minutes to shut down
+            }, { wait: DAEMON_SHUTDOWN_TIMEOUT_MS } // could take two minutes to shut down
             );
             // Emergency cleanup: if the process force-exits (e.g. double Ctrl+C),
-            // synchronously SIGKILL kubo's process group. This is a no-op if
-            // killKuboProcess() already ran (it sets kuboProcess = undefined).
+            // synchronously SIGKILL every live kubo's process group. This is a no-op if
+            // killKuboProcess() already ran (it clears kuboProcess and liveKuboPids).
             process.on("exit", () => {
                 if (kuboProcess?.pid) {
                     killKuboProcessGroup(kuboProcess.pid, "SIGKILL");
                 }
+                for (const pid of liveKuboPids)
+                    killKuboProcessGroup(pid, "SIGKILL");
             });
+            // Persistent signal guard (issue #70): exit-hook registers its SIGINT/SIGTERM handlers
+            // with process.once, so its listener vanishes from the listener list the moment a
+            // signal is dispatched. signal-exit (loaded by @pkcprotocol/proper-lock-file and other
+            // dependencies) re-raises the signal when every remaining listener is its own — which
+            // would kill the process while the async exit hook above is still shutting kubo down.
+            // A persistent non-signal-exit listener keeps that heuristic from ever firing.
+            // A repeated signal force-quits immediately (impatient Ctrl+C): process.exit triggers
+            // the emergency "exit" handler above, which SIGKILLs every live kubo.
+            let terminationSignalCount = 0;
+            for (const signal of ["SIGINT", "SIGTERM"]) {
+                process.on(signal, () => {
+                    terminationSignalCount++;
+                    if (terminationSignalCount >= 2) {
+                        log(`Received ${signal} again during shutdown, force-quitting`);
+                        process.exit(signal === "SIGINT" ? 130 : 143);
+                    }
+                });
+            }
+            // Test hook (issue #70): simulates a dependency registering a signal-exit handler
+            // AFTER the asyncExitHook above — what @pkcprotocol/proper-lock-file (and the
+            // signal-exit copies under ink/restore-cursor) do at module load. signal-exit
+            // re-raises the signal when every remaining listener belongs to the signal-exit
+            // family (`if (listeners.length === count) { ... process.kill(process.pid, s) }`),
+            // which kills the daemon while the async exit hook is still cleaning up kubo —
+            // exit-hook registers with process.once, so its listener is already gone by then.
+            if (process.env["PKC_CLI_TEST_SIMULATE_LATE_SIGNAL_EXIT"]) {
+                for (const signal of ["SIGINT", "SIGTERM"]) {
+                    // Real signal-exit copies only count each other as "family" (via a shared
+                    // global marker); any other listener makes them defer. Identify family by
+                    // source: signal-exit's dispatcher carries the "an exit is coming" comment.
+                    const isSignalExitFamily = (listener) => String(listener).includes("an exit is coming");
+                    const reRaiser = () => {
+                        const onlyFamilyLeft = process
+                            .listeners(signal)
+                            .every((listener) => listener === reRaiser || isSignalExitFamily(listener));
+                        if (onlyFamilyLeft) {
+                            process.removeListener(signal, reRaiser);
+                            process.kill(process.pid, signal);
+                        }
+                    };
+                    process.on(signal, reRaiser);
+                }
+            }
             // RPC port was already verified free above (fail-fast); only the kuboRpcClientsOptions branch skips local kubo.
             if (!pkcOptionsFromFlag?.kuboRpcClientsOptions)
                 await keepKuboUp();

package/dist/cli/commands/logs.js

@@ -163,6 +163,14 @@ export default class Logs extends Command {
         // Follow mode: dump existing content (filtered + tailed) then watch for new data
         let currentLogFile = latestLogFile;
         const existingContent = await fsPromise.readFile(currentLogFile, "utf-8");
+        // Anchor the follow offset to exactly the bytes we just read, NOT a separate
+        // fsPromise.stat() taken afterwards. A later stat is racy: any append landing between
+        // this read and the stat is skipped (position jumps past it) yet was never in the dump
+        // above, so follow mode silently drops those lines. Under load that window widens — this
+        // was the cause of the intermittent CI failure where an appended line was never surfaced
+        // (issue #77). Byte length (not string length) because position indexes bytes in the file.
+        let position = Buffer.byteLength(existingContent, "utf-8");
+        let pendingBuffer = "";
         const entries = this._parseLogEntries(existingContent);
         const filtered = this._filterEntries(entries, since, until);
         const streamFiltered = streamFilter ? this._filterByStream(filtered, streamFilter) : filtered;
@@ -170,9 +178,6 @@ export default class Logs extends Command {
         const initialOutput = tailed.map((e) => e.lines.join("\n")).join("\n");
         if (initialOutput)
             process.stdout.write(initialOutput + "\n");
-        const stat = await fsPromise.stat(currentLogFile);
-        let position = stat.size;
-        let pendingBuffer = "";
         // Watch for new data by reading directly from `position`. We intentionally do
         // NOT gate on fsPromise.stat().size — on Windows + NTFS, stat() returns a stale
         // size for a short window after another process appends, which causes the gate

package/dist/cli/commands/update/install.d.ts

@@ -10,5 +10,11 @@ export default class Install extends Command {
     };
     static examples: string[];
     run(): Promise<void>;
+    /**
+     * Poll until the given PID no longer exists (signal 0 throws ESRCH), or the timeout elapses.
+     * Returns true if the process exited, false on timeout. EPERM means the process is still alive
+     * but owned by another user, so we keep waiting.
+     */
+    private _waitForProcessExit;
     private _restartDaemons;
 }

package/dist/cli/commands/update/install.js

@@ -4,7 +4,7 @@ import tcpPortUsed from "tcp-port-used";
 import { fetchLatestVersion, installGlobal } from "../../../update/npm-registry.js";
 import { fastInstallGlobal } from "../../../update/fast-update.js";
 import { compareVersions } from "../../../update/semver.js";
-import { getAliveDaemonStates } from "../../../common-utils/daemon-state.js";
+import { getAliveDaemonStates, DAEMON_SHUTDOWN_TIMEOUT_MS } from "../../../common-utils/daemon-state.js";
 export default class Install extends Command {
     static description = "Install a specific version of bitsocial from npm";
     static args = {
@@ -54,15 +54,17 @@ export default class Install extends Command {
                     throw e;
                 }
             }
-            // Wait for all daemon ports to be free
+            // Wait for each daemon process to fully exit — NOT just for its RPC port to free.
+            // The daemon releases its RPC port (daemonServer.destroy()) before it finishes killing
+            // its kubo child, so a port-only wait lets us restart while the old kubo still holds the
+            // IPFS API port; the new daemon then dies on startup with "IPFS API port already in use"
+            // (issue #70). The daemon's exit hook kills kubo before the process exits, so waiting for
+            // the PID to disappear guarantees the kubo port is free before we restart.
             for (const d of aliveDaemons) {
-                const url = new URL(d.pkcRpcUrl);
-                const port = Number(url.port);
-                const host = url.hostname;
-                this.log(`Waiting for port ${port} to be free...`);
-                const freed = await tcpPortUsed.waitUntilFree(port, 500, 30000).then(() => true).catch(() => false);
-                if (!freed) {
-                    this.error(`Daemon (PID ${d.pid}) did not shut down within 30 seconds on port ${port}.`, { exit: 1 });
+                this.log(`Waiting for daemon (PID ${d.pid}) to exit...`);
+                const exited = await this._waitForProcessExit(d.pid, DAEMON_SHUTDOWN_TIMEOUT_MS);
+                if (!exited) {
+                    this.error(`Daemon (PID ${d.pid}) did not shut down within ${DAEMON_SHUTDOWN_TIMEOUT_MS / 1000} seconds.`, { exit: 1 });
                 }
             }
             this.log("All daemons stopped.");
@@ -118,6 +120,33 @@ export default class Install extends Command {
             this.log("To see the daemon logs run `bitsocial logs --stdout`");
         }
     }
+    /**
+     * Poll until the given PID no longer exists (signal 0 throws ESRCH), or the timeout elapses.
+     * Returns true if the process exited, false on timeout. EPERM means the process is still alive
+     * but owned by another user, so we keep waiting.
+     */
+    async _waitForProcessExit(pid, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (e) {
+                if (e.code === "ESRCH")
+                    return true; // no such process — it exited
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        // Final check so a process that exits in the last interval isn't reported as a timeout
+        try {
+            process.kill(pid, 0);
+        }
+        catch (e) {
+            if (e.code === "ESRCH")
+                return true;
+        }
+        return false;
+    }
     async _restartDaemons(daemons) {
         this.log(`Restarting ${daemons.length} daemon(s)...`);
         for (const d of daemons) {

package/dist/common-utils/daemon-state.d.ts

@@ -1,8 +1,17 @@
+/**
+ * Maximum time a daemon is allowed to shut down its kubo + RPC server during its
+ * async exit hook. The `update install --restart-daemons` orchestrator must wait at
+ * least this long for a stopped daemon's PID to disappear before giving up — otherwise
+ * a slow-but-valid shutdown (within the daemon's own contract) aborts the update midway.
+ */
+export declare const DAEMON_SHUTDOWN_TIMEOUT_MS = 120000;
 export interface DaemonState {
     pid: number;
     startedAt: string;
     argv: string[];
     pkcRpcUrl: string;
+    /** OS-reported process start time, used to detect PID reuse. Absent in legacy state files. */
+    procStartTime?: string;
 }
 /** Write a daemon state file atomically (write to .tmp then rename). */
 export declare function writeDaemonState(state: DaemonState): Promise<void>;
@@ -10,7 +19,7 @@ export declare function writeDaemonState(state: DaemonState): Promise<void>;
 export declare function readAllDaemonStates(): Promise<DaemonState[]>;
 /** Delete a specific daemon's state file. Ignores ENOENT. */
 export declare function deleteDaemonState(pid: number): Promise<void>;
-/** Delete state files for dead PIDs from disk. */
+/** Delete state files for dead or reused PIDs from disk. */
 export declare function pruneStaleStates(): Promise<void>;
-/** Read all states, delete stale files (dead PIDs) from disk, return only alive ones. */
+/** Read all states, delete stale files (dead or reused PIDs) from disk, return only alive ones. */
 export declare function getAliveDaemonStates(): Promise<DaemonState[]>;

package/dist/common-utils/daemon-state.js

@@ -1,12 +1,67 @@
 import defaults from "./defaults.js";
 import path from "path";
 import fs from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
 const DAEMON_STATES_DIR = path.join(defaults.PKC_DATA_PATH, ".daemon_states");
+/**
+ * Maximum time a daemon is allowed to shut down its kubo + RPC server during its
+ * async exit hook. The `update install --restart-daemons` orchestrator must wait at
+ * least this long for a stopped daemon's PID to disappear before giving up — otherwise
+ * a slow-but-valid shutdown (within the daemon's own contract) aborts the update midway.
+ */
+export const DAEMON_SHUTDOWN_TIMEOUT_MS = 120000;
 function stateFilePath(pid) {
     return path.join(DAEMON_STATES_DIR, `${pid}-daemon.state`);
 }
+/**
+ * OS-reported start time of a process, used as an identity token: if a state file's PID
+ * was reused by an unrelated process, its start time won't match the recorded one.
+ * Linux: starttime (field 22) of /proc/<pid>/stat, in clock ticks since boot.
+ * Other unix: `ps -o lstart=` output. Returns undefined when it can't be determined.
+ */
+async function getProcessStartTime(pid) {
+    try {
+        const stat = await fs.readFile(`/proc/${pid}/stat`, "utf-8");
+        // comm (field 2) may contain spaces/parens — real fields resume after the last ')'
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+        return fields[19]; // field 22 (starttime), offset by the 3 fields before the split
+    }
+    catch {
+        try {
+            const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="]);
+            return stdout.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+/** Full command line of a process, or undefined when it can't be determined. */
+async function getProcessCommandLine(pid) {
+    try {
+        // An empty /proc cmdline is meaningful (kernel thread — not a daemon), so keep it
+        const raw = await fs.readFile(`/proc/${pid}/cmdline`, "utf-8");
+        return raw.split("\0").join(" ").trim();
+    }
+    catch {
+        try {
+            const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "args="]);
+            return stdout.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
 /** Write a daemon state file atomically (write to .tmp then rename). */
 export async function writeDaemonState(state) {
+    if (state.procStartTime === undefined) {
+        const procStartTime = await getProcessStartTime(state.pid);
+        if (procStartTime !== undefined)
+            state = { ...state, procStartTime };
+    }
     await fs.mkdir(DAEMON_STATES_DIR, { recursive: true });
     const dest = stateFilePath(state.pid);
     const tmp = dest + ".tmp";
@@ -60,21 +115,37 @@ function isPidAlive(pid) {
         return false; // ESRCH — no such process
     }
 }
-/** Delete state files for dead PIDs from disk. */
-export async function pruneStaleStates() {
-    const states = await readAllDaemonStates();
-    for (const state of states) {
-        if (!isPidAlive(state.pid)) {
-            await deleteDaemonState(state.pid);
-        }
+/**
+ * Check whether the daemon that wrote `state` is still the process running under its PID.
+ * A bare liveness check is not enough: a stale state file's PID may have been reused by an
+ * unrelated process (e.g. a state file written inside a Docker container whose PID maps to
+ * a kernel thread on the host — issue #66).
+ */
+async function isDaemonStateAlive(state) {
+    if (!isPidAlive(state.pid))
+        return false;
+    if (state.procStartTime !== undefined) {
+        const current = await getProcessStartTime(state.pid);
+        if (current !== undefined)
+            return current === state.procStartTime; // mismatch — PID was reused
+        return true; // identity undeterminable — fall back to liveness only
     }
+    // Legacy state file without procStartTime — heuristic: the command line must reference bitsocial
+    const cmdline = await getProcessCommandLine(state.pid);
+    if (cmdline === undefined)
+        return true; // identity undeterminable — fall back to liveness only
+    return cmdline.includes("bitsocial");
+}
+/** Delete state files for dead or reused PIDs from disk. */
+export async function pruneStaleStates() {
+    await getAliveDaemonStates();
 }
-/** Read all states, delete stale files (dead PIDs) from disk, return only alive ones. */
+/** Read all states, delete stale files (dead or reused PIDs) from disk, return only alive ones. */
 export async function getAliveDaemonStates() {
     const states = await readAllDaemonStates();
     const alive = [];
     for (const state of states) {
-        if (isPidAlive(state.pid)) {
+        if (await isDaemonStateAlive(state)) {
             alive.push(state);
         }
         else {

package/dist/ipfs/startIpfs.js

@@ -185,53 +185,53 @@ async function ensureIpfsPortsAreAvailable(log, configPath, apiUrl, gatewayUrl)
     }
 }
 export async function startKuboNode(apiUrl, gatewayUrl, dataPath, onSpawn) {
-    return new Promise(async (resolve, reject) => {
-        const log = PKCLogger("bitsocial-cli:ipfs:startKuboNode");
-        const ipfsDataPath = process.env["IPFS_PATH"] || path.join(dataPath, ".bitsocial-cli.ipfs");
-        await fs.promises.mkdir(ipfsDataPath, { recursive: true });
-        const ipfsConfigPath = path.join(ipfsDataPath, "config");
-        const kuboExePath = await getKuboExePath();
-        const kuboVersion = await getKuboVersion();
-        log(`Using Kubo version: ${kuboVersion}`);
-        log(`IpfsDataPath (${ipfsDataPath}), kuboExePath (${kuboExePath})`, "kubo ipfs config file", path.join(ipfsDataPath, "config"));
-        log("If you would like to change kubo config, please edit the config file at", path.join(ipfsDataPath, "config"));
-        const env = { IPFS_PATH: ipfsDataPath, DEBUG_COLORS: "1" };
-        let configJustInitialized = false;
-        try {
-            await _spawnAsync(log, kuboExePath, ["init"], { env, hideWindows: true });
-            configJustInitialized = true;
-        }
-        catch (e) {
-            const error = e;
-            if (!error?.message?.includes("ipfs configuration file already exists!"))
-                throw new Error("Failed to call ipfs init" + error);
-        }
-        if (configJustInitialized) {
-            await _spawnAsync(log, kuboExePath, ["config", "profile", "apply", `server`], {
-                env,
-                hideWindows: true
-            });
-            log("Called 'ipfs config profile apply server' successfully");
-            await mergeCliDefaultsIntoIpfsConfig(log, ipfsConfigPath, apiUrl, gatewayUrl);
-        }
-        else {
-            log("IPFS config already exists; skipping config overrides to preserve user changes.");
-        }
-        try {
-            await _spawnAsync(log, kuboExePath, ["repo", "migrate"], { env, hideWindows: true });
-            log("Ensured IPFS repository is migrated to the latest supported version.");
-        }
-        catch (migrationError) {
-            log.error("Failed to run IPFS repo migrations automatically", migrationError);
-            throw migrationError;
-        }
-        try {
-            await ensureIpfsPortsAreAvailable(log, ipfsConfigPath, apiUrl, gatewayUrl);
-        }
-        catch (error) {
-            reject(error instanceof Error ? error : new Error(String(error)));
-            return;
-        }
+    // Preparation phase runs as plain awaits so any failure rejects the returned promise.
+    // It must NOT live inside the new Promise() executor below: an async executor swallows
+    // throws as unhandledRejections and the promise never settles, which wedges the daemon's
+    // pendingKuboStart tracking and hangs its shutdown (issue #70).
+    const log = PKCLogger("bitsocial-cli:ipfs:startKuboNode");
+    const ipfsDataPath = process.env["IPFS_PATH"] || path.join(dataPath, ".bitsocial-cli.ipfs");
+    await fs.promises.mkdir(ipfsDataPath, { recursive: true });
+    const ipfsConfigPath = path.join(ipfsDataPath, "config");
+    const kuboExePath = await getKuboExePath();
+    const kuboVersion = await getKuboVersion();
+    log(`Using Kubo version: ${kuboVersion}`);
+    log(`IpfsDataPath (${ipfsDataPath}), kuboExePath (${kuboExePath})`, "kubo ipfs config file", path.join(ipfsDataPath, "config"));
+    log("If you would like to change kubo config, please edit the config file at", path.join(ipfsDataPath, "config"));
+    const env = { IPFS_PATH: ipfsDataPath, DEBUG_COLORS: "1" };
+    let configJustInitialized = false;
+    try {
+        await _spawnAsync(log, kuboExePath, ["init"], { env, hideWindows: true });
+        configJustInitialized = true;
+    }
+    catch (e) {
+        const error = e;
+        if (!error?.message?.includes("ipfs configuration file already exists!"))
+            throw new Error("Failed to call ipfs init" + error);
+    }
+    if (configJustInitialized) {
+        await _spawnAsync(log, kuboExePath, ["config", "profile", "apply", `server`], {
+            env,
+            hideWindows: true
+        });
+        log("Called 'ipfs config profile apply server' successfully");
+        await mergeCliDefaultsIntoIpfsConfig(log, ipfsConfigPath, apiUrl, gatewayUrl);
+    }
+    else {
+        log("IPFS config already exists; skipping config overrides to preserve user changes.");
+    }
+    try {
+        await _spawnAsync(log, kuboExePath, ["repo", "migrate"], { env, hideWindows: true });
+        log("Ensured IPFS repository is migrated to the latest supported version.");
+    }
+    catch (migrationError) {
+        log.error("Failed to run IPFS repo migrations automatically", migrationError);
+        throw migrationError;
+    }
+    await ensureIpfsPortsAreAvailable(log, ipfsConfigPath, apiUrl, gatewayUrl);
+    // Spawn phase: the promise only wraps the event-driven wait for kubo's "Daemon is ready",
+    // so every settle path goes through resolve/reject.
+    return new Promise((resolve, reject) => {
         const daemonArgs = ["--enable-namesys-pubsub", "--migrate"];
         const kuboProcess = spawn(kuboExePath, ["daemon", ...daemonArgs], {
             env,

package/dist/webui/daemon-server.js

@@ -6,7 +6,7 @@ import fs from "fs/promises";
 import { PKCLogger } from "../util.js";
 import { randomBytes } from "crypto";
 import express from "express";
-import { loadChallengesIntoPKC } from "../challenge-packages/challenge-utils.js";
+import { loadChallengesIntoPKC, formatChallengeNameVersion } from "../challenge-packages/challenge-utils.js";
 const rootHashRedirectScriptPattern = /<script\b[^>]*>(?:(?!<\/script>)[\s\S])*?window\.location\.replace\(["']\/#["']\s*\+\s*window\.location\.pathname\s*\+\s*window\.location\.search\);(?:(?!<\/script>)[\s\S])*?<\/script>/;
 async function _generateModifiedIndexHtmlWithRpcSettings(webuiPath, webuiName, ipfsGatewayPort) {
     const indexHtmlString = (await fs.readFile(path.join(webuiPath, "index_backup_no_rpc.html")))
@@ -124,7 +124,7 @@ export async function startDaemonServer(rpcUrl, ipfsGatewayUrl, pkcOptions, rpcS
     // Challenge reload endpoints
     const handleChallengeReload = async (_req, res) => {
         try {
-            const loadedNames = await loadChallengesIntoPKC(pkcOptions.dataPath);
+            const loadedChallenges = await loadChallengesIntoPKC(pkcOptions.dataPath);
             // Notify all connected RPC clients about the updated challenges
             const onSettingsChange = rpcServer._onSettingsChange;
             if (onSettingsChange) {
@@ -139,7 +139,7 @@ export async function startDaemonServer(rpcUrl, ipfsGatewayUrl, pkcOptions, rpcS
                     }
                 }
             }
-            res.json({ ok: true, challenges: loadedNames });
+            res.json({ ok: true, challenges: loadedChallenges.map(formatChallengeNameVersion) });
         }
         catch (err) {
             log.error("Failed to reload challenges", err);