@bitsocial/bitsocial-cli 0.19.39

package/dist/seeder.js

@@ -0,0 +1,83 @@
+// import lodash from "lodash";
+// import Logger from "@plebbit/plebbit-logger";
+// import { Plebbit } from "@plebbit/plebbit-js/dist/node/plebbit";
+// import { BasePages } from "@plebbit/plebbit-js/dist/node/pages";
+// import { Comment } from "@plebbit/plebbit-js/dist/node/comment";
+// import assert from "assert";
+// //@ts-expect-error
+// import { CID } from "ipfs-http-client";
+// import { Subplebbit } from "@plebbit/plebbit-js/dist/node/subplebbit/subplebbit";
+export {};
+// async function _loadAllPages(pageCid: string, pagesInstance: BasePages): Promise<Comment[]> {
+//     const log = Logger("plebbit-cli:server:seed:_loadAllPages");
+//     try {
+//         let sortedCommentsPage = await pagesInstance.getPage(pageCid);
+//         let sortedComments: Comment[] = sortedCommentsPage.comments;
+//         while (sortedCommentsPage.nextCid) {
+//             sortedCommentsPage = await pagesInstance.getPage(sortedCommentsPage.nextCid);
+//             sortedComments = sortedComments.concat(sortedCommentsPage.comments);
+//         }
+//         return sortedComments;
+//     } catch (e) {
+//         log.error(`Failed to load page (${pageCid}) of sub (${pagesInstance._subplebbitAddress}) due to error:`, e);
+//         return [];
+//     }
+// }
+// const seededIpns: Record<string, { lastSeededAt?: number }> = {};
+// async function _seedSub(sub: Subplebbit, pinnedCids: string[]) {
+//     const log = Logger("plebbit-cli:server:seed");
+//     if (sub.statsCid) await sub.plebbit.fetchCid(sub.statsCid); // Seed stats
+//     await sub.plebbit.pubsubSubscribe(sub.pubsubTopic || sub.address);
+//     // Load all pages
+//     if (sub.posts.pageCids) {
+//         const pagesLoaded = await Promise.all(Object.values(sub.posts.pageCids).map((pageCid) => _loadAllPages(pageCid, sub.posts)));
+//         // What if one of pages fail to load
+//         log.trace(`Loaded the newest pages of sub (${sub.address}) to seed`);
+//         const pageNames = Object.keys(sub.posts.pageCids);
+//         const loadedPagesWithNames = lodash.zipObject(pageNames, pagesLoaded);
+//         const allCidsToPin: string[] = [];
+//         if (loadedPagesWithNames["new"]) {
+//             // Fetch all comments CID
+//             allCidsToPin.push(...loadedPagesWithNames["new"].map((comment) => <string>comment.cid));
+//             // Seed IPNS
+//             for (const comment of loadedPagesWithNames["new"]) {
+//                 assert(comment.ipnsName);
+//                 if (seededIpns[comment.ipnsName]?.lastSeededAt !== comment.updatedAt) {
+//                     try {
+//                         await comment._clientsManager.fetchCommentUpdate(comment.ipnsName);
+//                         seededIpns[comment.ipnsName] = { lastSeededAt: comment.updatedAt };
+//                         log.trace(`Seeded comment (${comment.cid}) IPNS (${comment.ipnsName})`);
+//                     } catch (e) {
+//                         log.error(`Failed to seed comment (${comment.cid}) IPNS (${comment.ipnsName}) due to error`, e);
+//                     }
+//                 }
+//             }
+//         }
+//         // Pin cids that are not already pinned
+//         const newCidsToPin = lodash.difference(lodash.uniq(allCidsToPin), pinnedCids).map((cidString) => CID.parse(cidString));
+//         if (newCidsToPin.length > 0) {
+//             log.trace(`Attempting to pin ${newCidsToPin.length} comments' cids from sub (${sub.address}): `, newCidsToPin);
+//             const defaultIpfsClient = Object.values(sub.plebbit.clients.ipfsClients)[0];
+//             assert(defaultIpfsClient);
+//             await defaultIpfsClient._client.pin.addAll(newCidsToPin);
+//             log.trace(`Pinned ${newCidsToPin.length} cids from sub (${sub.address})`);
+//         } else log.trace(`All ${lodash.uniq(allCidsToPin).length} cids from sub (${sub.address}) are pinned`);
+//     }
+// }
+// export async function seedSubplebbits(subAddresses: string[], plebbit: Plebbit) {
+//     const log = Logger("plebbit-cli:server:seed");
+//     log.trace("test"); // remove this line later
+//     for (const subAddress of subAddresses) {
+//         try {
+//             const sub = await plebbit.getSubplebbit(subAddress);
+//             log.trace(`Loaded the newest record of sub (${subAddress}) for seeding`);
+//             const defaultIpfsClient = Object.values(sub.plebbit.clients.ipfsClients)[0];
+//             assert(defaultIpfsClient);
+//             const pinnedCids: string[] = (await defaultIpfsClient._client.pin.ls()).map((pin) => pin.cid.toString());
+//             await _seedSub(sub, pinnedCids);
+//         } catch (e) {
+//             log.error(`Failed to load and seed sub (${subAddress}):`, String(e));
+//         }
+//     }
+//     log(`Finished this round of seeding. Will seed again later`);
+// }

package/dist/update/npm-registry.d.ts

@@ -0,0 +1,6 @@
+/** Query npm registry for the latest published version. */
+export declare function fetchLatestVersion(): Promise<string>;
+/** Query npm registry for all published versions (oldest-first). */
+export declare function fetchAllVersions(): Promise<string[]>;
+/** Install a specific version globally via npm install -g. Streams output to terminal. */
+export declare function installGlobal(version: string): Promise<void>;

package/dist/update/npm-registry.js

@@ -0,0 +1,66 @@
+import { spawn } from "child_process";
+import { getNpmCliPath, getNpmEnv, ensureNpmAvailable } from "../challenge-packages/challenge-utils.js";
+const PACKAGE_NAME = "@bitsocial/bitsocial-cli";
+function runNpmView(args) {
+    return new Promise(async (resolve, reject) => {
+        const npmCliPath = await getNpmCliPath();
+        const proc = spawn(process.execPath, [npmCliPath, "view", PACKAGE_NAME, ...args, "--json"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: getNpmEnv()
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to run npm view: ${err.message}`));
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`npm view exited with code ${code}: ${stderr.trim()}`));
+            }
+        });
+    });
+}
+/** Query npm registry for the latest published version. */
+export async function fetchLatestVersion() {
+    await ensureNpmAvailable();
+    const raw = await runNpmView(["version"]);
+    // npm view <pkg> version --json returns a quoted string like "0.19.40"
+    return JSON.parse(raw);
+}
+/** Query npm registry for all published versions (oldest-first). */
+export async function fetchAllVersions() {
+    await ensureNpmAvailable();
+    const raw = await runNpmView(["versions"]);
+    return JSON.parse(raw);
+}
+/** Install a specific version globally via npm install -g. Streams output to terminal. */
+export async function installGlobal(version) {
+    await ensureNpmAvailable();
+    const npmCliPath = await getNpmCliPath();
+    return new Promise((resolve, reject) => {
+        const proc = spawn(process.execPath, [npmCliPath, "install", "-g", `${PACKAGE_NAME}@${version}`], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: getNpmEnv()
+        });
+        proc.stdout?.pipe(process.stdout);
+        proc.stderr?.pipe(process.stderr);
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to run npm install: ${err.message}`));
+        });
+        proc.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`npm install -g exited with code ${code}`));
+        });
+    });
+}

package/dist/update/semver.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Minimal semver comparison. Strips leading "v", splits on ".",
+ * compares each segment numerically left-to-right.
+ */
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;

package/dist/update/semver.js

@@ -0,0 +1,29 @@
+/**
+ * Minimal semver comparison. Strips leading "v", splits on ".",
+ * compares each segment numerically left-to-right.
+ */
+export function compareVersions(a, b) {
+    const normalize = (v) => v.replace(/^v/i, "");
+    const partsA = normalize(a).split(".").map(Number);
+    const partsB = normalize(b).split(".").map(Number);
+    const len = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < len; i++) {
+        const na = partsA[i] ?? 0;
+        const nb = partsB[i] ?? 0;
+        if (Number.isNaN(na) || Number.isNaN(nb)) {
+            // Fall back to string compare for non-numeric segments
+            const sa = String(partsA[i] ?? "");
+            const sb = String(partsB[i] ?? "");
+            if (sa < sb)
+                return -1;
+            if (sa > sb)
+                return 1;
+            continue;
+        }
+        if (na < nb)
+            return -1;
+        if (na > nb)
+            return 1;
+    }
+    return 0;
+}

package/dist/util.d.ts

@@ -0,0 +1,31 @@
+export type PKCLogger = Awaited<ReturnType<typeof getPKCLogger>> & {
+    inspectOpts?: {
+        depth?: number;
+        colors?: boolean;
+        [key: string]: any;
+    };
+};
+export declare function getPKCLogger(): Promise<typeof import("@pkcprotocol/pkc-logger").default>;
+/**
+ * Read _PKC_DEBUG / DEBUG env vars and configure the Logger instance.
+ * Does NOT redirect output — debug logs go to stderr (the default for the debug module).
+ *
+ * @param options.enableDefaultNamespace - If true, enable "bitsocial*,pkc*,-pkc*trace"
+ *   when no DEBUG env is set (used by daemon). If false, only enable if user
+ *   explicitly set DEBUG or _PKC_DEBUG (used by non-daemon commands).
+ */
+export declare function setupDebugLogger(Logger: PKCLogger, options?: {
+    enableDefaultNamespace?: boolean;
+}): {
+    debugNamespace: string | undefined;
+    debugDepth: number;
+};
+export declare function getLanIpV4Address(): string | undefined;
+export declare function loadKuboConfigFile(pkcDataPath: string): Promise<any | undefined>;
+export declare function parseMultiAddrKuboRpcToUrl(kuboMultiAddrString: string): Promise<import("url").URL>;
+export declare function parseMultiAddrIpfsGatewayToUrl(ipfsGatewaymultiAddrString: string): Promise<import("url").URL>;
+/**
+ * Custom merge function that implements CLI-specific merge behavior.
+ * This matches the expected behavior from the test suite.
+ */
+export declare function mergeDeep(target: any, source: any): any;

package/dist/util.js

@@ -0,0 +1,157 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+import * as fsPromises from "fs/promises";
+export async function getPKCLogger() {
+    const Logger = await import("@pkcprotocol/pkc-logger");
+    return Logger.default;
+}
+/**
+ * Read _PKC_DEBUG / DEBUG env vars and configure the Logger instance.
+ * Does NOT redirect output — debug logs go to stderr (the default for the debug module).
+ *
+ * @param options.enableDefaultNamespace - If true, enable "bitsocial*,pkc*,-pkc*trace"
+ *   when no DEBUG env is set (used by daemon). If false, only enable if user
+ *   explicitly set DEBUG or _PKC_DEBUG (used by non-daemon commands).
+ */
+export function setupDebugLogger(Logger, options = {}) {
+    const envDebug = process.env["_PKC_DEBUG"] || process.env["DEBUG"];
+    const debugNamespace = envDebug === "0" || envDebug === "" ? undefined : envDebug;
+    const debugDepth = process.env["DEBUG_DEPTH"] ? parseInt(process.env["DEBUG_DEPTH"]) : 10;
+    Logger.inspectOpts = Logger.inspectOpts || {};
+    Logger.inspectOpts.depth = debugDepth;
+    const defaultNamespace = "bitsocial*,pkc*,-pkc*trace";
+    if (debugNamespace) {
+        Logger.enable(debugNamespace);
+    }
+    else if (options.enableDefaultNamespace) {
+        Logger.enable(defaultNamespace);
+    }
+    return { debugNamespace, debugDepth };
+}
+export function getLanIpV4Address() {
+    const allInterfaces = os.networkInterfaces();
+    for (const k in allInterfaces) {
+        const specificInterfaceInfos = allInterfaces[k];
+        if (!specificInterfaceInfos)
+            continue;
+        const lanAddress = specificInterfaceInfos.filter((info) => info.family === "IPv4" && !info.internal)[0]
+            ?.address;
+        if (lanAddress)
+            return lanAddress;
+    }
+    return undefined;
+}
+export async function loadKuboConfigFile(pkcDataPath) {
+    const kuboConfigPath = path.join(pkcDataPath, ".ipfs-bitsocial-cli", "config");
+    if (!fs.existsSync(kuboConfigPath))
+        return undefined;
+    const kuboConfig = JSON.parse((await fsPromises.readFile(kuboConfigPath)).toString());
+    return kuboConfig;
+}
+async function parseMultiAddr(multiAddrString) {
+    const module = await import("@multiformats/multiaddr");
+    return module.multiaddr(multiAddrString);
+}
+function multiAddrToHostPort(multiAddrObj) {
+    const components = multiAddrObj.getComponents();
+    const hostComponent = components.find((component) => ["ip4", "ip6", "dns", "dns4", "dns6", "dnsaddr"].includes(component.name));
+    const tcpComponent = components.find((component) => component.name === "tcp");
+    const host = hostComponent?.value;
+    const port = tcpComponent?.value ? Number(tcpComponent.value) : undefined;
+    if (!host || !port || !Number.isFinite(port) || port <= 0)
+        return undefined;
+    return { host, port };
+}
+export async function parseMultiAddrKuboRpcToUrl(kuboMultiAddrString) {
+    const multiAddrObj = await parseMultiAddr(kuboMultiAddrString);
+    const parsed = multiAddrToHostPort(multiAddrObj);
+    if (!parsed)
+        throw new Error(`Unable to parse kubo RPC multiaddr: ${kuboMultiAddrString}`);
+    return new URL(`http://${parsed.host}:${parsed.port}/api/v0`);
+}
+export async function parseMultiAddrIpfsGatewayToUrl(ipfsGatewaymultiAddrString) {
+    const multiAddrObj = await parseMultiAddr(ipfsGatewaymultiAddrString);
+    const parsed = multiAddrToHostPort(multiAddrObj);
+    if (!parsed)
+        throw new Error(`Unable to parse IPFS gateway multiaddr: ${ipfsGatewaymultiAddrString}`);
+    return new URL(`http://${parsed.host}:${parsed.port}`);
+}
+/**
+ * Custom merge function that implements CLI-specific merge behavior.
+ * This matches the expected behavior from the test suite.
+ */
+export function mergeDeep(target, source) {
+    function isObject(item) {
+        return item && typeof item === "object" && !Array.isArray(item);
+    }
+    function isPlainObject(item) {
+        return isObject(item) && item.constructor === Object;
+    }
+    // Handle arrays with CLI-specific behavior
+    if (Array.isArray(target) && Array.isArray(source)) {
+        // Check if source is sparse (has holes/empty items) - indicates indexed assignment like --rules[2]
+        const sourceHasHoles = source.length !== Object.keys(source).length;
+        if (sourceHasHoles) {
+            // Sparse array: merge by index, extending to accommodate both arrays
+            const maxLength = Math.max(target.length, source.length);
+            const result = new Array(maxLength);
+            for (let i = 0; i < maxLength; i++) {
+                if (i in source) {
+                    if (i in target && isPlainObject(target[i]) && isPlainObject(source[i])) {
+                        result[i] = mergeDeep(target[i], source[i]);
+                    }
+                    else {
+                        result[i] = source[i];
+                    }
+                }
+                else if (i in target) {
+                    result[i] = target[i];
+                }
+                // If neither has this index, it remains undefined
+            }
+            return result;
+        }
+        else {
+            // Dense array: CLI behavior is to extend the array to include both original and new values
+            // This creates: [source[0], source[1], target[2], target[3], ...]
+            const maxLength = target.length + source.length;
+            const result = new Array(maxLength);
+            // First, place source values at the beginning
+            for (let i = 0; i < source.length; i++) {
+                result[i] = source[i];
+            }
+            // Then, place target values at their original indices (beyond source length)
+            for (let i = source.length; i < maxLength; i++) {
+                const targetIndex = i; // Use the same index, not shifted
+                if (targetIndex < target.length) {
+                    result[i] = target[targetIndex];
+                }
+                else {
+                    result[i] = undefined;
+                }
+            }
+            return result;
+        }
+    }
+    // Handle plain objects
+    if (isPlainObject(target) && isPlainObject(source)) {
+        const result = { ...target };
+        for (const key in source) {
+            if (source.hasOwnProperty(key)) {
+                if (Array.isArray(target[key]) && Array.isArray(source[key])) {
+                    result[key] = mergeDeep(target[key], source[key]);
+                }
+                else if (isPlainObject(target[key]) && isPlainObject(source[key])) {
+                    result[key] = mergeDeep(target[key], source[key]);
+                }
+                else {
+                    result[key] = source[key];
+                }
+            }
+        }
+        return result;
+    }
+    // If not both objects/arrays, source takes precedence
+    return source;
+}

package/dist/webui/daemon-server.d.ts

@@ -0,0 +1,10 @@
+export declare function startDaemonServer(rpcUrl: URL, ipfsGatewayUrl: URL, pkcOptions: any): Promise<{
+    rpcAuthKey: string;
+    listedSub: string[];
+    webuis: {
+        name: string;
+        endpointLocal: string;
+        endpointRemote: string;
+    }[];
+    destroy: () => Promise<void>;
+}>;

package/dist/webui/daemon-server.js

@@ -0,0 +1,140 @@
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import fs from "fs/promises";
+import { getPKCLogger } from "../util.js";
+import { randomBytes } from "crypto";
+import express from "express";
+import { loadChallengesIntoPKC } from "../challenge-packages/challenge-utils.js";
+async function _generateModifiedIndexHtmlWithRpcSettings(webuiPath, webuiName, ipfsGatewayPort) {
+    const indexHtmlString = (await fs.readFile(path.join(webuiPath, "index_backup_no_rpc.html")))
+        .toString()
+        .replace(/<script>\s*\/\/\s*Redirect non-hash URLs[\s\S]*?<\/script>/, "");
+    const defaultRpcOptionString = `[window.location.origin.replace("https://", "wss://").replace("http://", "ws://") + window.location.pathname.split('/' + '${webuiName}')[0]]`;
+    // Ipfs media only locally because ipfs gateway doesn't allow remote connections
+    const defaultIpfsMedia = `if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname === "0.0.0.0")window.defaultMediaIpfsGatewayUrl = 'http://' + window.location.hostname + ':' + ${ipfsGatewayPort}`;
+    const defaultOptionsString = `<script>window.defaultPkcOptions = {pkcRpcClientsOptions: ${defaultRpcOptionString}};${defaultIpfsMedia};console.log(window.defaultPkcOptions, window.defaultMediaIpfsGatewayUrl)</script>`;
+    const modifiedIndexHtmlContent = "<!DOCTYPE html>" + defaultOptionsString + indexHtmlString.replace("<!DOCTYPE html>", "");
+    return modifiedIndexHtmlContent;
+}
+async function _generateRpcAuthKeyIfNotExisting(pkcDataPath) {
+    const pkcRpcAuthKeyPath = path.join(pkcDataPath, "auth-key");
+    const envAuthKey = process.env["PKC_RPC_AUTH_KEY"];
+    let pkcRpcAuthKey;
+    if (envAuthKey) {
+        pkcRpcAuthKey = envAuthKey;
+        await fs.writeFile(pkcRpcAuthKeyPath, pkcRpcAuthKey);
+    }
+    else {
+        try {
+            pkcRpcAuthKey = await fs.readFile(pkcRpcAuthKeyPath, "utf-8");
+        }
+        catch (e) {
+            pkcRpcAuthKey = randomBytes(32).toString("base64").replace(/[/+=]/g, "").substring(0, 40);
+            await fs.writeFile(pkcRpcAuthKeyPath, pkcRpcAuthKey, { flag: "wx" });
+        }
+    }
+    return pkcRpcAuthKey;
+}
+// The daemon server will host both RPC and webui on the same port
+export async function startDaemonServer(rpcUrl, ipfsGatewayUrl, pkcOptions) {
+    // Start pkc-js RPC
+    const log = (await getPKCLogger())("bitsocial-cli:daemon:startDaemonServer");
+    const webuiExpressApp = express();
+    const httpServer = webuiExpressApp.listen(Number(rpcUrl.port));
+    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");
+    // Will add ability to edit later, but it's hard coded for now
+    log("Will be passing pkc options to RPC server", pkcOptions);
+    const rpcServer = await PKCRpc.default.PKCWsServer({
+        server: httpServer,
+        pkcOptions: pkcOptions,
+        authKey: rpcAuthKey
+    });
+    const webuisDir = path.join(__dirname, "..", "..", "dist", "webuis");
+    const webUiNames = (await fs.readdir(webuisDir, { withFileTypes: true })).filter((file) => file.isDirectory()).map((file) => file.name);
+    const webuis = [];
+    log("Discovered webuis", webUiNames);
+    for (const webuiNameWithVersion of webUiNames) {
+        const webuiDirPath = path.join(webuisDir, webuiNameWithVersion);
+        const webuiName = webuiNameWithVersion.split("-")[0]; // should be "seedit", "plebones"
+        const modifiedIndexHtmlString = await _generateModifiedIndexHtmlWithRpcSettings(webuiDirPath, webuiName, Number(ipfsGatewayUrl.port));
+        const endpointLocal = `/${webuiName}`;
+        webuiExpressApp.use(endpointLocal, express.static(webuiDirPath, { index: false }));
+        webuiExpressApp.get(endpointLocal, (req, res, next) => {
+            const isLocal = req.socket.localAddress && req.socket.localAddress === req.socket.remoteAddress;
+            log("Received local connection request for webui", endpointLocal, "with socket.localAddress", req.socket.localAddress, "and socket.remoteAddress", req.socket.remoteAddress);
+            if (!isLocal)
+                res.status(403).send("This endpoint does not exist for remote connections");
+            else {
+                res.set("Cache-Control", "no-store, no-cache, must-revalidate, private");
+                res.set("Expires", "-1");
+                res.set("Pragma", "no-cache");
+                res.type("html").send(modifiedIndexHtmlString);
+            }
+        });
+        const endpointRemote = `/${rpcAuthKey}/${webuiName}`;
+        webuiExpressApp.use(endpointRemote, express.static(webuiDirPath, { index: false }));
+        webuiExpressApp.get(endpointRemote, (req, res, next) => {
+            const isLocal = req.socket.localAddress && req.socket.localAddress === req.socket.remoteAddress;
+            log("Received remote connection request for webui", endpointLocal, "with socket.localAddress", req.socket.localAddress, "and socket.remoteAddress", req.socket.remoteAddress, "with req.url", req.url);
+            if (isLocal) {
+                res.redirect(`http://localhost:${rpcUrl.port}/${webuiName}`);
+            }
+            else {
+                res.set("Cache-Control", "public, max-age=600"); // 600 seconds = 10 minutes
+                res.type("html").send(modifiedIndexHtmlString);
+            }
+        });
+        webuis.push({ name: webuiName, endpointLocal, endpointRemote });
+    }
+    // Challenge reload endpoints
+    const handleChallengeReload = async (_req, res) => {
+        try {
+            const loadedNames = await loadChallengesIntoPKC(pkcOptions.dataPath);
+            // Notify all connected RPC clients about the updated challenges
+            const onSettingsChange = rpcServer._onSettingsChange;
+            if (onSettingsChange) {
+                for (const connectionId of Object.keys(onSettingsChange)) {
+                    const handlers = onSettingsChange[connectionId];
+                    if (!handlers)
+                        continue;
+                    for (const subscriptionId of Object.keys(handlers)) {
+                        const handler = handlers[subscriptionId];
+                        if (handler)
+                            await handler({ newPKC: rpcServer.pkc });
+                    }
+                }
+            }
+            res.json({ ok: true, challenges: loadedNames });
+        }
+        catch (err) {
+            log.error("Failed to reload challenges", err);
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    };
+    // Local-only endpoint (same isLocal check as webui routes)
+    webuiExpressApp.post("/api/challenges/reload", (req, res) => {
+        const isLocal = req.socket.localAddress && req.socket.localAddress === req.socket.remoteAddress;
+        if (!isLocal) {
+            res.status(403).send("This endpoint does not exist for remote connections");
+            return;
+        }
+        handleChallengeReload(req, res);
+    });
+    // Remote endpoint with auth key
+    webuiExpressApp.post(`/${rpcAuthKey}/api/challenges/reload`, (req, res) => {
+        handleChallengeReload(req, res);
+    });
+    let daemonServerDestroyed = false;
+    const cleanupDaemonServer = async () => {
+        if (daemonServerDestroyed)
+            return;
+        await rpcServer.destroy();
+        httpServer.close();
+        daemonServerDestroyed = true;
+    };
+    return { rpcAuthKey, listedSub: rpcServer.pkc.communities, webuis, destroy: cleanupDaemonServer };
+}