@bitsocial/bitsocial-cli 0.19.39

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

@@ -0,0 +1,9 @@
+import { Command } from "@oclif/core";
+export default class Versions extends Command {
+    static description: string;
+    static flags: {
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,29 @@
+import { Command, Flags } from "@oclif/core";
+import { fetchAllVersions } from "../../../update/npm-registry.js";
+export default class Versions extends Command {
+    static description = "List available bitsocial versions on npm";
+    static flags = {
+        limit: Flags.integer({
+            description: "Maximum number of versions to display",
+            default: 20
+        })
+    };
+    static examples = ["bitsocial update versions", "bitsocial update versions --limit 5"];
+    async run() {
+        const { flags } = await this.parse(Versions);
+        let versions;
+        try {
+            versions = await fetchAllVersions();
+        }
+        catch (err) {
+            this.error(`Failed to fetch versions: ${err.message}`, { exit: 1 });
+        }
+        const current = this.config.version;
+        // Show newest first, limited to --limit
+        const display = versions.slice(-flags.limit).reverse();
+        for (const v of display) {
+            const marker = v === current ? "* " : "  ";
+            this.log(`${marker}${v}`);
+        }
+    }
+}

package/dist/cli/hooks/init/version-hook.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from "@oclif/core";
+declare const hook: Hook<"init">;
+export default hook;

package/dist/cli/hooks/init/version-hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+// Get pkc-js version from its package.json
+const getPkcJsVersion = () => {
+    const require = createRequire(import.meta.url);
+    // Get path to pkc-js module
+    const pkcJsPath = require.resolve("@pkcprotocol/pkc-js");
+    // Navigate to package root (pkc-js main export is dist/node/index.js)
+    const pkcJsRoot = dirname(dirname(dirname(pkcJsPath)));
+    const pkcPkgPath = join(pkcJsRoot, "package.json");
+    const pkcPkg = JSON.parse(readFileSync(pkcPkgPath, "utf-8"));
+    return pkcPkg.version;
+};
+// Get commit hash from CLI's package.json dependency URL (if installed from git)
+const getPkcJsCommit = (cliRoot) => {
+    try {
+        const cliPkgPath = join(cliRoot, "package.json");
+        const cliPkg = JSON.parse(readFileSync(cliPkgPath, "utf-8"));
+        const pkcJsDep = cliPkg.dependencies["@pkcprotocol/pkc-js"];
+        // Extract commit hash from URL like "https://github.com/pkcprotocol/pkc-js#542952a1..."
+        const match = pkcJsDep?.match(/#([a-f0-9]+)$/);
+        return match ? match[1].substring(0, 7) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const hook = async function (opts) {
+    // Check process.argv because oclif normalizes argv and --version becomes the id, not part of argv
+    if (process.argv.includes("--version")) {
+        const { config } = opts;
+        const pkcJsVersion = getPkcJsVersion();
+        const commit = getPkcJsCommit(config.root);
+        const commitStr = commit ? ` (${commit})` : "";
+        // Output CLI version on first line, pkc-js version + commit on second line
+        this.log(`${config.name}/${config.version} ${config.platform}-${config.arch} node-${process.version}`);
+        this.log(`pkc-js/${pkcJsVersion}${commitStr}`);
+        // Use process.exit to actually stop - this.exit(0) throws an error that gets caught by oclif
+        process.exit(0);
+    }
+};
+export default hook;

package/dist/cli/hooks/prerun/parse-dynamic-flags-hook.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from "@oclif/core";
+declare const hook: Hook<"prerun">;
+export default hook;

package/dist/cli/hooks/prerun/parse-dynamic-flags-hook.js

@@ -0,0 +1,94 @@
+import { Flags } from "@oclif/core";
+import * as remeda from "remeda";
+const parseCommandInputToProperType = (input) => {
+    if (input === "true")
+        return true;
+    else if (input === "false")
+        return false;
+    else if (input === "null")
+        return null;
+    else if (input.trim() !== "" && !Number.isNaN(Number(input)))
+        return Number(input);
+    else
+        return input;
+};
+const parseFlags = (argv) => {
+    const args = argv;
+    return args.reduce((accumulator, currentArg, index) => {
+        // Skip if not a flag
+        if (!currentArg.startsWith("--")) {
+            return accumulator;
+        }
+        const flag = currentArg.slice(2); // Remove '--'
+        // Handle --flag=value syntax
+        if (flag.includes("=")) {
+            const [flagPath, value] = flag.split("=");
+            return setNestedValue(accumulator, flagPath, value);
+        }
+        const nextArg = args[index + 1];
+        // Handle boolean flags (no value or next arg is a flag)
+        if (!nextArg || nextArg.startsWith("--")) {
+            return setNestedValue(accumulator, flag, true);
+        }
+        // Handle regular --flag value syntax
+        return setNestedValue(accumulator, flag, nextArg);
+    }, {});
+};
+// Helper function to set nested values
+const setNestedValue = (obj, path, value) => {
+    const keys = path.split(".");
+    const lastKey = keys.pop();
+    // Traverse/create nested objects
+    let current = obj;
+    keys.forEach((key) => {
+        current[key] = current[key] || {};
+        current = current[key];
+    });
+    // Set or append value at final position
+    if (typeof value === "boolean") {
+        current[lastKey] = value;
+    }
+    else {
+        current[lastKey] = [...(current[lastKey] || []), value];
+    }
+    return obj;
+};
+const traverseObjectToSetAsFlagInOclif = (opts, flagsGrouped, path = "") => {
+    for (const flagName of Object.keys(flagsGrouped)) {
+        if (remeda.isPlainObject(flagsGrouped[flagName])) {
+            traverseObjectToSetAsFlagInOclif(opts, flagsGrouped[flagName], path + flagName + ".");
+            if (Object.keys(flagsGrouped[flagName]).length !== 0)
+                continue;
+        }
+        const flagsIndices = Object.assign({}, ...Object.keys(flagsGrouped).map((flag) => ({ [flag]: 0 })));
+        const multipleValues = Array.isArray(flagsGrouped[flagName]) && flagsGrouped[flagName].length > 1;
+        const parsedValue = flagsGrouped[flagName];
+        if (typeof parsedValue === "boolean")
+            opts.Command.flags[path + flagName] = Flags.boolean({ default: true });
+        else
+            opts.Command.flags[path + flagName] = Flags.string({
+                //@ts-expect-error
+                multiple: multipleValues,
+                parse: async (input) => {
+                    const parsed = parseCommandInputToProperType(parsedValue[flagsIndices[flagName]++]);
+                    return parsed;
+                }
+            });
+    }
+};
+const hook = async function (opts) {
+    // Need to parse flag here and add it to opts.Command._flags
+    if (opts.Command.id === "community:edit" || opts.Command.id === "community:create" || opts.Command.id === "daemon") {
+        // Parse the dynamic flags and add them to opts.Command.flags so that it wouldn't throw
+        if (opts.argv.length <= 1)
+            return; // if no flags are provided, then we don't need to do anything
+        for (let i = 0; i < opts.argv.length; i++)
+            if (typeof opts.argv[i] !== "string")
+                opts.argv[i] = String(opts.argv[i]);
+        const flagsGrouped = parseFlags(opts.Command.id === "daemon" ? ["", ...opts.argv] : opts.argv);
+        if (Object.keys(flagsGrouped).length > 0 && !opts.Command.flags)
+            opts.Command.flags = {};
+        traverseObjectToSetAsFlagInOclif(opts, flagsGrouped);
+    }
+};
+export default hook;

package/dist/cli/types.d.ts

@@ -0,0 +1,4 @@
+import type { CreateNewLocalCommunityUserOptions as PKCCreateCommunityOptions } from "@pkcprotocol/pkc-js/dist/node/community/types.js";
+export interface CliCreateCommunityOptions extends Pick<PKCCreateCommunityOptions, "title" | "description" | "suggested" | "settings" | "features" | "roles" | "rules" | "flairs"> {
+    privateKeyPath?: string;
+}

package/dist/cli/types.js

@@ -0,0 +1 @@
+export {};

package/dist/common-utils/data-migration.d.ts

@@ -0,0 +1 @@
+export declare function migrateDataDirectory(dataPath: string): void;

package/dist/common-utils/data-migration.js

@@ -0,0 +1,27 @@
+import fs from "fs";
+import path from "path";
+import envPaths from "env-paths";
+export function migrateDataDirectory(dataPath) {
+    const defaultNewPath = envPaths("bitsocial", { suffix: "" }).data;
+    const defaultOldPath = envPaths("plebbit", { suffix: "" }).data;
+    // Step 1: Migrate old default dir (envPaths("plebbit")) → new default (envPaths("bitsocial"))
+    if (dataPath === defaultNewPath && fs.existsSync(defaultOldPath)) {
+        if (!fs.existsSync(defaultNewPath)) {
+            fs.renameSync(defaultOldPath, defaultNewPath);
+            console.log(`Migrated data directory: ${defaultOldPath} → ${defaultNewPath}`);
+        }
+        else {
+            console.warn(`Both ${defaultOldPath} and ${defaultNewPath} exist. Using ${defaultNewPath}.`);
+        }
+    }
+    // Step 2: Migrate subplebbits/ → communities/ inside data directory
+    const oldSubDir = path.join(dataPath, "subplebbits");
+    const newSubDir = path.join(dataPath, "communities");
+    if (fs.existsSync(oldSubDir) && !fs.existsSync(newSubDir)) {
+        fs.renameSync(oldSubDir, newSubDir);
+        console.log(`Migrated ${oldSubDir} → ${newSubDir}`);
+    }
+    else if (fs.existsSync(oldSubDir) && fs.existsSync(newSubDir)) {
+        console.warn(`Both ${oldSubDir} and ${newSubDir} exist. Using ${newSubDir}.`);
+    }
+}

package/dist/common-utils/defaults.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    PKC_DATA_PATH: string;
+    PKC_RPC_URL: import("url").URL;
+    KUBO_RPC_URL: import("url").URL;
+    IPFS_GATEWAY_URL: import("url").URL;
+    HTTP_TRACKERS: string[];
+    PKC_LOG_PATH: string;
+};
+export default _default;

package/dist/common-utils/defaults.js

@@ -0,0 +1,10 @@
+// Not sure 'defaults' is the best name here
+import envPaths from "env-paths";
+export default {
+    PKC_DATA_PATH: envPaths("bitsocial", { suffix: "" }).data,
+    PKC_RPC_URL: new URL("ws://localhost:9138"),
+    KUBO_RPC_URL: new URL(process.env["KUBO_RPC_URL"] || "http://127.0.0.1:50019/api/v0"),
+    IPFS_GATEWAY_URL: new URL(process.env["IPFS_GATEWAY_URL"] || "http://127.0.0.1:6473"),
+    HTTP_TRACKERS: ["https://peers.pleb.bot", "https://routing.lol", "https://peers.forumindex.com", "https://peers.plebpubsub.xyz"],
+    PKC_LOG_PATH: envPaths("bitsocial", { suffix: "" }).log
+};

package/dist/common-utils/resolvers.d.ts

@@ -0,0 +1,2 @@
+import { BsoResolver } from "@bitsocial/bso-resolver";
+export declare function createBsoResolvers(providers?: string[], dataPath?: string): BsoResolver[];

package/dist/common-utils/resolvers.js

@@ -0,0 +1,6 @@
+import { BsoResolver } from "@bitsocial/bso-resolver";
+const DEFAULT_PROVIDERS = ["viem", "https://ethrpc.xyz"];
+export function createBsoResolvers(providers, dataPath) {
+    const resolverProviders = providers && providers.length > 0 ? providers : DEFAULT_PROVIDERS;
+    return resolverProviders.map((provider) => new BsoResolver({ key: `bso-${provider}`, provider, dataPath }));
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/ipfs/startIpfs.d.ts

@@ -0,0 +1,3 @@
+import { ChildProcessWithoutNullStreams } from "child_process";
+export declare function mergeCliDefaultsIntoIpfsConfig(log: any, ipfsConfigPath: string, apiUrl: URL, gatewayUrl: URL): Promise<void>;
+export declare function startKuboNode(apiUrl: URL, gatewayUrl: URL, dataPath: string, onSpawn?: (process: ChildProcessWithoutNullStreams) => void): Promise<ChildProcessWithoutNullStreams>;

package/dist/ipfs/startIpfs.js

@@ -0,0 +1,304 @@
+import { spawn } from "child_process";
+import path from "path";
+import fs from "fs";
+import * as fsPromises from "fs/promises";
+import assert from "assert";
+import tcpPortUsed from "tcp-port-used";
+import { path as ipfsExePathFunc } from "kubo";
+import { getPKCLogger } from "../util.js";
+async function getKuboExePath() {
+    return ipfsExePathFunc();
+}
+async function getKuboVersion() {
+    const kuboPackageJson = await import("kubo/package.json", { with: { type: "json" } });
+    return kuboPackageJson.default.version;
+}
+export async function mergeCliDefaultsIntoIpfsConfig(log, ipfsConfigPath, apiUrl, gatewayUrl) {
+    const currentIpfsConfigFile = JSON.parse((await fsPromises.readFile(ipfsConfigPath)).toString());
+    const existingGatewayConfig = currentIpfsConfigFile["Gateway"] ?? {};
+    const existingPublicGatewaysConfig = existingGatewayConfig["PublicGateways"] ?? {};
+    const gatewayPublicGateways = {};
+    for (const [hostname, gatewayConfig] of Object.entries(existingPublicGatewaysConfig)) {
+        if (typeof gatewayConfig === "object" && gatewayConfig !== null) {
+            gatewayPublicGateways[hostname] = { ...gatewayConfig, UseSubdomains: false };
+        }
+        else {
+            gatewayPublicGateways[hostname] = { UseSubdomains: false };
+        }
+    }
+    const canonicalGatewayHostname = gatewayUrl.hostname.includes(":") ? `[${gatewayUrl.hostname}]` : gatewayUrl.hostname;
+    const hostnamesForDefaults = new Set([canonicalGatewayHostname, "localhost", "127.0.0.1", "[::1]"]);
+    for (const hostname of hostnamesForDefaults) {
+        if (!hostname)
+            continue;
+        const existingConfig = gatewayPublicGateways[hostname];
+        const normalizedExistingConfig = typeof existingConfig === "object" && existingConfig !== null ? { ...existingConfig } : {};
+        const paths = Array.isArray(normalizedExistingConfig.Paths) && normalizedExistingConfig.Paths.length > 0
+            ? normalizedExistingConfig.Paths
+            : ["/ipfs/", "/ipns/"];
+        gatewayPublicGateways[hostname] = {
+            ...normalizedExistingConfig,
+            InlineDNSLink: normalizedExistingConfig.InlineDNSLink !== undefined ? normalizedExistingConfig.InlineDNSLink : false,
+            UseSubdomains: false,
+            Paths: paths
+        };
+    }
+    const mergedIpfsConfig = {
+        ...currentIpfsConfigFile,
+        Addresses: {
+            ...(currentIpfsConfigFile["Addresses"] ?? {}),
+            Gateway: `/ip4/${gatewayUrl.hostname}/tcp/${gatewayUrl.port}`,
+            API: `/ip4/${apiUrl.hostname}/tcp/${apiUrl.port}`,
+            Swarm: [
+                "/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"
+            ]
+        },
+        AutoTLS: {
+            ...(currentIpfsConfigFile["AutoTLS"] ?? {}),
+            Enabled: true
+        },
+        Gateway: {
+            ...existingGatewayConfig,
+            PublicGateways: gatewayPublicGateways
+        }
+    };
+    await fsPromises.writeFile(ipfsConfigPath, JSON.stringify(mergedIpfsConfig, null, 4));
+    log("Applied bitsocial CLI defaults to freshly initialized IPFS config.", ipfsConfigPath);
+}
+// use this custom function instead of spawnSync for better logging
+// also spawnSync might have been causing crash on start on windows
+function _spawnAsync(log, ...args) {
+    return new Promise((resolve, reject) => {
+        //@ts-ignore
+        const spawedProcess = 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);
+            }
+        });
+        spawedProcess.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) => {
+            errorMessage += data.toString();
+            log.error(data.toString());
+        });
+    });
+}
+let cachedMultiaddrFactory;
+async function getMultiaddrFactory() {
+    if (!cachedMultiaddrFactory) {
+        const module = (await import("@multiformats/multiaddr"));
+        cachedMultiaddrFactory = module.multiaddr;
+    }
+    return cachedMultiaddrFactory;
+}
+async function parseTcpMultiaddr(multiAddrString) {
+    if (!multiAddrString)
+        return undefined;
+    try {
+        const factory = await getMultiaddrFactory();
+        const address = factory(multiAddrString);
+        const components = address.getComponents();
+        const tcpComponent = components.find((component) => component.name === "tcp");
+        const hostComponent = components.find((component) => ["ip4", "ip6", "dns", "dns4", "dns6", "dnsaddr"].includes(component.name));
+        const host = hostComponent?.value;
+        const portValue = tcpComponent?.value ? Number(tcpComponent.value) : undefined;
+        if (!host || !portValue || !Number.isFinite(portValue) || portValue <= 0)
+            return undefined;
+        return { host, port: portValue };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function ensureIpfsPortsAreAvailable(log, configPath, apiUrl, gatewayUrl) {
+    let configRaw;
+    try {
+        configRaw = await fsPromises.readFile(configPath, "utf-8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to read IPFS config at ${configPath} to validate ports: ${message}`);
+    }
+    let config;
+    try {
+        config = JSON.parse(configRaw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to parse IPFS config at ${configPath} to validate ports: ${message}`);
+    }
+    const addresses = config?.Addresses ?? {};
+    const checks = new Map();
+    const addCheck = (label, host, port, source) => {
+        if (!host || typeof host !== "string")
+            return;
+        if (!Number.isFinite(port) || port <= 0)
+            return;
+        const key = `${label}|${host}:${port}`;
+        if (!checks.has(key))
+            checks.set(key, { label, host, port, source });
+    };
+    const apiMultiAddr = typeof addresses.API === "string" ? await parseTcpMultiaddr(addresses.API) : undefined;
+    if (apiMultiAddr)
+        addCheck("IPFS API", apiMultiAddr.host, apiMultiAddr.port, addresses.API);
+    else if (apiUrl?.hostname) {
+        const fallbackPort = Number(apiUrl.port || (apiUrl.protocol === "https:" ? 443 : 80));
+        if (Number.isFinite(fallbackPort) && fallbackPort > 0)
+            addCheck("IPFS API", apiUrl.hostname, fallbackPort, apiUrl.toString());
+    }
+    const gatewayMultiAddr = typeof addresses.Gateway === "string" ? await parseTcpMultiaddr(addresses.Gateway) : undefined;
+    if (gatewayMultiAddr)
+        addCheck("IPFS Gateway", gatewayMultiAddr.host, gatewayMultiAddr.port, addresses.Gateway);
+    else if (gatewayUrl?.hostname) {
+        const fallbackPort = Number(gatewayUrl.port || (gatewayUrl.protocol === "https:" ? 443 : 80));
+        if (Number.isFinite(fallbackPort) && fallbackPort > 0)
+            addCheck("IPFS Gateway", gatewayUrl.hostname, fallbackPort, gatewayUrl.toString());
+    }
+    const swarmAddresses = Array.isArray(addresses.Swarm)
+        ? addresses.Swarm.filter((addr) => typeof addr === "string")
+        : typeof addresses.Swarm === "string"
+            ? [addresses.Swarm]
+            : [];
+    for (const swarmAddr of swarmAddresses) {
+        const parsed = await parseTcpMultiaddr(swarmAddr);
+        if (parsed)
+            addCheck("IPFS Swarm", parsed.host, parsed.port, swarmAddr);
+    }
+    for (const check of checks.values()) {
+        const inUse = await tcpPortUsed.check(check.port, check.host);
+        log.trace?.(`Validating ${check.label} port ${check.host}:${check.port} (source: ${check.source}) - in use: ${inUse}`);
+        if (inUse) {
+            throw new Error(`Cannot start IPFS daemon because the ${check.label} port ${check.host}:${check.port} (configured as ${check.source}) is already in use.`);
+        }
+    }
+}
+export async function startKuboNode(apiUrl, gatewayUrl, dataPath, onSpawn) {
+    return new Promise(async (resolve, reject) => {
+        const log = (await getPKCLogger())("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;
+        }
+        const daemonArgs = ["--enable-namesys-pubsub", "--migrate"];
+        const kuboProcess = spawn(kuboExePath, ["daemon", ...daemonArgs], {
+            env,
+            cwd: process.cwd(),
+            detached: true
+        });
+        onSpawn?.(kuboProcess);
+        log.trace(`Kubo ipfs daemon process started with pid ${kuboProcess.pid} and args`, daemonArgs);
+        let lastError = "Kubo process exited before Daemon was ready."; // Default error for premature exit
+        let daemonReady = false;
+        // Define handlers upfront to allow removal
+        const onProcessExit = () => {
+            if (!daemonReady) {
+                // Only reject if daemon wasn't ready (i.e., startup failed)
+                log.error(`Kubo ipfs process with pid ${kuboProcess.pid} exited prematurely. Last error: ${lastError}`);
+                // Clean up all listeners associated with this promise to prevent multiple rejections or logs from this context
+                kuboProcess.removeAllListeners();
+                reject(new Error(lastError));
+            }
+            else {
+                // If daemon was already ready, this exit is handled by listeners in daemon.ts (e.g., keepKuboUp or asyncExitHook)
+                log.trace(`Kubo ipfs process with pid ${kuboProcess.pid} exited after daemon was ready.`);
+            }
+        };
+        const onProcessError = (err) => {
+            lastError = err.message || "Kubo process encountered an error during startup.";
+            log.error(`Kubo process error: ${lastError}`);
+            if (!daemonReady) {
+                // Only reject if daemon wasn't ready
+                kuboProcess.removeAllListeners();
+                reject(err);
+            }
+        };
+        const onDaemonReadyOutput = (data) => {
+            const output = data.toString();
+            log.trace(output);
+            if (output.match("Daemon is ready")) {
+                daemonReady = true;
+                assert(typeof kuboProcess.pid === "number", `kuboProcess.pid (${kuboProcess.pid}) is not a valid pid`);
+                const delayRaw = process.env["PKC_CLI_TEST_IPFS_READY_DELAY_MS"];
+                const readyDelay = delayRaw ? Number(delayRaw) : 0;
+                const completeResolve = () => {
+                    // IMPORTANT: Remove promise-specific handlers once startup is successful
+                    kuboProcess.removeListener("exit", onProcessExit);
+                    kuboProcess.removeListener("error", onProcessError);
+                    // Stderr listener can remain for ongoing logging if desired, or be removed too.
+                    // kuboProcess.stderr.removeListener("data", onStderrData); // If you want to stop this specific stderr logging
+                    resolve(kuboProcess);
+                };
+                if (Number.isFinite(readyDelay) && readyDelay > 0)
+                    setTimeout(completeResolve, readyDelay);
+                else
+                    completeResolve();
+            }
+        };
+        const onStderrData = (data) => {
+            const errorOutput = data.toString();
+            lastError = errorOutput; // Keep track of the last thing seen on stderr for error reporting
+            log.error(errorOutput); // Log all stderr output
+        };
+        kuboProcess.stderr.on("data", onStderrData);
+        // kuboProcess.stdin.on("data", (data) => log.trace(data.toString())); // Listening on child's stdin is unusual, usually for writing.
+        kuboProcess.stdout.on("data", onDaemonReadyOutput);
+        kuboProcess.on("error", onProcessError); // For spawn errors or other direct errors from the process object itself
+        kuboProcess.on("exit", onProcessExit); // For when the process terminates
+    });
+}

package/dist/seeder.d.ts

@@ -0,0 +1 @@
+export {};