feat: report community status after daemon restart in update install

Rinse12 · Rinse12 · commit 600151766905 · 2026-04-19T08:11:05.000Z
After restarting daemons, connect to each daemon's RPC and check how many communities are started, providing user feedback about auto-start progress. Ref #26
diff --git a/src/cli/commands/update/install.ts b/src/cli/commands/update/install.ts
@@ -4,6 +4,14 @@ import tcpPortUsed from "tcp-port-used";
 import { fetchLatestVersion, installGlobal } from "../../../update/npm-registry.js";
 import { compareVersions } from "../../../update/semver.js";
 import { getAliveDaemonStates, type DaemonState } from "../../../common-utils/daemon-state.js";
+import PKC from "@pkcprotocol/pkc-js";
+type PKCInstance = Awaited<ReturnType<typeof PKC>>;
+type PKCConnectOverride = (pkcRpcUrl: string) => Promise<PKCInstance>;
+
+const getPKCConnectOverride = (): PKCConnectOverride | undefined => {
+    const globalWithOverride = globalThis as { __PKC_RPC_CONNECT_OVERRIDE?: PKCConnectOverride };
+    return globalWithOverride.__PKC_RPC_CONNECT_OVERRIDE;
+};
 
 export default class Install extends Command {
     static override description = "Install a specific version of bitsocial from npm";
@@ -142,9 +150,63 @@ export default class Install extends Command {
             const started = await tcpPortUsed.waitUntilUsed(port, 500, 30000).then(() => true).catch(() => false);
             if (started) {
                 this.log(`  Daemon started (port ${port}).`);
+                await this._reportCommunityStatus(d.pkcRpcUrl);
             } else {
                 this.warn(`  Daemon may not have started — port ${port} not responding after 30s. Check logs with: bitsocial logs`);
             }
         }
     }
+
+    private async _connectToRpc(pkcRpcUrl: string): Promise<PKCInstance> {
+        const connectOverride = getPKCConnectOverride();
+        if (connectOverride) {
+            return connectOverride(pkcRpcUrl);
+        }
+        const pkc = await PKC({ pkcRpcClientsOptions: [pkcRpcUrl] });
+        const errors: Error[] = [];
+        pkc.on("error", (err: Error) => {
+            errors.push(err);
+        });
+        await new Promise<void>((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const lastError = errors[errors.length - 1];
+                reject(lastError ?? new Error(`Timed out waiting for RPC server at ${pkcRpcUrl} to respond`));
+            }, 20000);
+            pkc.once("communitieschange", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        return pkc;
+    }
+
+    private async _reportCommunityStatus(pkcRpcUrl: string): Promise<void> {
+        let pkc: PKCInstance | undefined;
+        try {
+            pkc = await this._connectToRpc(pkcRpcUrl);
+            const communities: string[] = pkc.communities;
+            if (communities.length === 0) return;
+
+            const statuses = await Promise.all(
+                communities.map(async (address: string) => {
+                    const community = await pkc!.createCommunity({ address });
+                    return community.started as boolean;
+                })
+            );
+            const startedCount = statuses.filter(Boolean).length;
+            const total = communities.length;
+
+            if (startedCount === total) {
+                this.log(`  ${startedCount} ${startedCount === 1 ? "community" : "communities"} started.`);
+            } else if (startedCount > 0) {
+                this.log(`  ${startedCount} of ${total} communities started (remaining still loading).`);
+            } else {
+                this.log(`  ${total} ${total === 1 ? "community" : "communities"} in data path (still loading). Check with: bitsocial community list`);
+            }
+        } catch {
+            this.warn("Could not check community status.");
+        } finally {
+            if (pkc) await pkc.destroy().catch(() => {});
+        }
+    }
 }
diff --git a/test/cli/update-install-community-status.test.ts b/test/cli/update-install-community-status.test.ts
@@ -0,0 +1,209 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import EventEmitter from "events";
+
+vi.mock("@pkcprotocol/pkc-js", () => ({
+    default: vi.fn()
+}));
+
+vi.mock("tcp-port-used", () => ({
+    default: {
+        waitUntilFree: vi.fn().mockResolvedValue(undefined),
+        waitUntilUsed: vi.fn().mockResolvedValue(undefined)
+    }
+}));
+
+vi.mock("child_process", async () => {
+    const actual = await vi.importActual<typeof import("child_process")>("child_process");
+    return {
+        ...actual,
+        spawn: vi.fn(() => ({ pid: 99999, unref: vi.fn() }))
+    };
+});
+
+vi.mock("../../src/common-utils/daemon-state.js", () => ({
+    getAliveDaemonStates: vi.fn().mockResolvedValue([])
+}));
+
+vi.mock("../../src/update/npm-registry.js", () => ({
+    fetchLatestVersion: vi.fn().mockResolvedValue("99.99.99"),
+    installGlobal: vi.fn().mockResolvedValue(undefined)
+}));
+
+vi.mock("../../src/update/semver.js", () => ({
+    compareVersions: vi.fn().mockReturnValue(-1)
+}));
+
+describe("update install — community status reporting", () => {
+    let logOutput: string[];
+    let warnOutput: string[];
+
+    beforeEach(() => {
+        logOutput = [];
+        warnOutput = [];
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    async function createInstallCommand() {
+        const mod = await import("../../src/cli/commands/update/install.js");
+        const Install = mod.default;
+        const cmd = new Install([], { version: "0.0.1" } as any);
+        cmd.log = (...args: any[]) => logOutput.push(args.join(" "));
+        cmd.warn = (...args: any[]) => warnOutput.push(args.join(" "));
+        cmd.parse = vi.fn().mockResolvedValue({
+            args: { version: "latest" },
+            flags: { force: false, "restart-daemons": true }
+        });
+        cmd.error = vi.fn((msg: string) => {
+            throw new Error(msg);
+        }) as any;
+        return cmd;
+    }
+
+    it("prints started count when all communities are started", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        const fakePkc = Object.assign(new EventEmitter(), {
+            communities: ["community1.bso", "community2.bso"],
+            createCommunity: vi.fn().mockResolvedValue({ started: true }),
+            destroy: vi.fn().mockResolvedValue(undefined)
+        });
+        vi.mocked(PKCMock).mockImplementation(async () => {
+            // Auto-emit communitieschange after a tick
+            setTimeout(() => fakePkc.emit("communitieschange"), 0);
+            return fakePkc as any;
+        });
+
+        const cmd = await createInstallCommand();
+        await cmd.run();
+
+        const joined = logOutput.join("\n");
+        expect(joined).toContain("2 communities started");
+    });
+
+    it("prints partial count when some communities are still loading", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        let callCount = 0;
+        const fakePkc = Object.assign(new EventEmitter(), {
+            communities: ["community1.bso", "community2.bso", "community3.bso"],
+            createCommunity: vi.fn().mockImplementation(async () => {
+                callCount++;
+                return { started: callCount <= 1 };
+            }),
+            destroy: vi.fn().mockResolvedValue(undefined)
+        });
+        vi.mocked(PKCMock).mockImplementation(async () => {
+            setTimeout(() => fakePkc.emit("communitieschange"), 0);
+            return fakePkc as any;
+        });
+
+        const cmd = await createInstallCommand();
+        await cmd.run();
+
+        const joined = logOutput.join("\n");
+        expect(joined).toContain("1 of 3 communities started (remaining still loading)");
+    });
+
+    it("prints still loading message when no communities are started yet", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        const fakePkc = Object.assign(new EventEmitter(), {
+            communities: ["community1.bso", "community2.bso"],
+            createCommunity: vi.fn().mockResolvedValue({ started: false }),
+            destroy: vi.fn().mockResolvedValue(undefined)
+        });
+        vi.mocked(PKCMock).mockImplementation(async () => {
+            setTimeout(() => fakePkc.emit("communitieschange"), 0);
+            return fakePkc as any;
+        });
+
+        const cmd = await createInstallCommand();
+        await cmd.run();
+
+        const joined = logOutput.join("\n");
+        expect(joined).toContain("2 communities in data path (still loading)");
+        expect(joined).toContain("bitsocial community list");
+    });
+
+    it("prints nothing when there are no communities", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        const fakePkc = Object.assign(new EventEmitter(), {
+            communities: [],
+            createCommunity: vi.fn(),
+            destroy: vi.fn().mockResolvedValue(undefined)
+        });
+        vi.mocked(PKCMock).mockImplementation(async () => {
+            setTimeout(() => fakePkc.emit("communitieschange"), 0);
+            return fakePkc as any;
+        });
+
+        const cmd = await createInstallCommand();
+        await cmd.run();
+
+        const joined = logOutput.join("\n");
+        expect(joined).not.toContain("communities");
+        expect(joined).not.toContain("community");
+    });
+
+    it("warns but does not crash when RPC connection fails", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        vi.mocked(PKCMock).mockRejectedValue(new Error("Connection refused"));
+
+        const cmd = await createInstallCommand();
+        // Should not throw
+        await cmd.run();
+
+        const joinedWarns = warnOutput.join("\n");
+        expect(joinedWarns).toContain("Could not check community status");
+    });
+
+    it("prints singular 'community' for a single community", async () => {
+        const { getAliveDaemonStates } = await import("../../src/common-utils/daemon-state.js");
+        vi.mocked(getAliveDaemonStates).mockResolvedValue([
+            { pid: 12345, startedAt: "2026-01-01", argv: [], pkcRpcUrl: "ws://localhost:39123" }
+        ]);
+
+        const { default: PKCMock } = await import("@pkcprotocol/pkc-js");
+        const fakePkc = Object.assign(new EventEmitter(), {
+            communities: ["community1.bso"],
+            createCommunity: vi.fn().mockResolvedValue({ started: true }),
+            destroy: vi.fn().mockResolvedValue(undefined)
+        });
+        vi.mocked(PKCMock).mockImplementation(async () => {
+            setTimeout(() => fakePkc.emit("communitieschange"), 0);
+            return fakePkc as any;
+        });
+
+        const cmd = await createInstallCommand();
+        await cmd.run();
+
+        const joined = logOutput.join("\n");
+        expect(joined).toContain("1 community started");
+        expect(joined).not.toContain("communities started");
+    });
+});
