@bitsocial/bitsocial-cli 0.19.39

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

@@ -0,0 +1,131 @@
+import { Args, Flags, Command } from "@oclif/core";
+import path from "path";
+import fs from "fs/promises";
+import decompress from "decompress";
+import defaults from "../../../common-utils/defaults.js";
+import { ensureNpmAvailable, ensureChallengesDir, challengeNameToDir, readChallengePackageJson, runNpmPack, runNpmInstall, verifyNativeModuleAbi } from "../../../challenge-packages/challenge-utils.js";
+export default class Install extends Command {
+    static description = "Install a challenge package (npm package name, git URL, tarball URL, or local path)";
+    static args = {
+        package: Args.string({
+            description: "Package specifier — anything npm can install (name, name@version, git URL, tarball URL, local path)",
+            required: true
+        })
+    };
+    static flags = {
+        "pkcOptions.dataPath": Flags.directory({
+            description: "Data path to install the challenge into",
+            required: false
+        })
+    };
+    static examples = [
+        "bitsocial challenge install @bitsocial/mintpass-challenge",
+        "bitsocial challenge install @bitsocial/mintpass-challenge@1.0.0",
+        "bitsocial challenge install github:user/repo",
+        "bitsocial challenge install https://example.com/my-challenge-1.0.0.tar.gz",
+        "bitsocial challenge install ./my-local-challenge"
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Install);
+        const dataPath = flags["pkcOptions.dataPath"] || defaults.PKC_DATA_PATH;
+        this.log("Installing challenge package — this may take a few minutes...");
+        // 1. Check npm is available
+        await ensureNpmAvailable();
+        // 2. Use npm pack to download the package as a tarball
+        const tmpDir = path.join(dataPath, ".challenge-install-tmp-" + Date.now());
+        await fs.mkdir(tmpDir, { recursive: true });
+        try {
+            const archivePath = await runNpmPack(args.package, tmpDir);
+            // 3. Extract the archive
+            const extractDir = path.join(tmpDir, "extracted");
+            await decompress(archivePath, extractDir);
+            process.stderr.write("[challenge-install] archive extracted\n");
+            // 4. Find package.json (npm pack tarballs have a package/ root dir)
+            let pkgDir = extractDir;
+            try {
+                await readChallengePackageJson(pkgDir);
+            }
+            catch {
+                // Check one level deep
+                const entries = await fs.readdir(extractDir, { withFileTypes: true });
+                const dirs = entries.filter((e) => e.isDirectory());
+                let found = false;
+                for (const dir of dirs) {
+                    const candidate = path.join(extractDir, dir.name);
+                    try {
+                        await readChallengePackageJson(candidate);
+                        pkgDir = candidate;
+                        found = true;
+                        break;
+                    }
+                    catch {
+                        // continue
+                    }
+                }
+                if (!found) {
+                    this.error("No valid package.json found in the archive. The archive must contain a package.json with a \"name\" field.");
+                }
+            }
+            // 5. Read package info
+            const pkg = await readChallengePackageJson(pkgDir);
+            // 6. Check not already installed
+            const challengesDir = await ensureChallengesDir(dataPath);
+            const destDir = challengeNameToDir(challengesDir, pkg.name);
+            let alreadyExists = true;
+            try {
+                await fs.access(destDir);
+            }
+            catch {
+                alreadyExists = false;
+            }
+            if (alreadyExists) {
+                this.error(`Challenge "${pkg.name}" is already installed. Remove it first with: bitsocial challenge remove ${pkg.name}`);
+            }
+            // 7. Move to challenges dir
+            if (pkg.name.startsWith("@")) {
+                // Ensure scope dir exists for scoped packages
+                const scopeDir = path.dirname(destDir);
+                await fs.mkdir(scopeDir, { recursive: true });
+            }
+            await fs.rename(pkgDir, destDir);
+            // 8. Run npm install
+            process.stderr.write(`[challenge-install] starting npm install in ${destDir}\n`);
+            await runNpmInstall(destDir);
+            process.stderr.write("[challenge-install] npm install completed\n");
+            // 9. Verify native modules are ABI-compatible
+            try {
+                await verifyNativeModuleAbi(destDir);
+            }
+            catch (err) {
+                // Roll back the installation on ABI mismatch
+                await fs.rm(destDir, { recursive: true, force: true });
+                if (pkg.name.startsWith("@")) {
+                    const scopeDir = path.dirname(destDir);
+                    try {
+                        const entries = await fs.readdir(scopeDir);
+                        if (entries.length === 0)
+                            await fs.rmdir(scopeDir);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                this.error(err instanceof Error ? err.message : String(err));
+            }
+            // 10. Print success
+            const version = pkg.version ? `@${pkg.version}` : "";
+            this.log(`Installed challenge '${pkg.name}${version}'`);
+            // 11. Best-effort reload via daemon
+            try {
+                await fetch("http://localhost:9138/api/challenges/reload", { method: "POST" });
+            }
+            catch {
+                // daemon not running, that's fine
+            }
+        }
+        finally {
+            // 12. Clean up temp dir
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/cli/commands/challenge/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@oclif/core";
+export default class List extends Command {
+    static description: string;
+    static flags: {
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "pkcOptions.dataPath": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/cli/commands/challenge/list.js

@@ -0,0 +1,37 @@
+import { Flags, Command } from "@oclif/core";
+import { EOL } from "os";
+import { printTable } from "@oclif/table";
+import defaults from "../../../common-utils/defaults.js";
+import { listInstalledChallenges } from "../../../challenge-packages/challenge-utils.js";
+export default class List extends Command {
+    static description = "List installed challenge packages";
+    static flags = {
+        quiet: Flags.boolean({ char: "q", summary: "Only display challenge names" }),
+        "pkcOptions.dataPath": Flags.directory({
+            description: "Data path where challenges are installed",
+            required: false
+        })
+    };
+    static examples = ["bitsocial challenge list", "bitsocial challenge list -q"];
+    async run() {
+        const { flags } = await this.parse(List);
+        const dataPath = flags["pkcOptions.dataPath"] || defaults.PKC_DATA_PATH;
+        const challenges = await listInstalledChallenges(dataPath);
+        if (challenges.length === 0) {
+            this.log("No challenge packages installed.");
+            return;
+        }
+        if (flags.quiet) {
+            this.log(challenges.map((c) => c.name).join(EOL));
+        }
+        else {
+            printTable({
+                data: challenges.map((c) => ({
+                    name: c.name,
+                    version: c.version,
+                    description: c.description
+                }))
+            });
+        }
+    }
+}

package/dist/cli/commands/challenge/remove.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "@oclif/core";
+export default class Remove extends Command {
+    static description: string;
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        "pkcOptions.dataPath": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/cli/commands/challenge/remove.js

@@ -0,0 +1,60 @@
+import { Args, Flags, Command } from "@oclif/core";
+import fs from "fs/promises";
+import path from "path";
+import defaults from "../../../common-utils/defaults.js";
+import { getChallengesDir, challengeNameToDir } from "../../../challenge-packages/challenge-utils.js";
+export default class Remove extends Command {
+    static description = "Remove an installed challenge package";
+    static args = {
+        name: Args.string({
+            description: "The challenge package name (e.g., my-challenge or @scope/my-challenge)",
+            required: true
+        })
+    };
+    static flags = {
+        "pkcOptions.dataPath": Flags.directory({
+            description: "Data path where challenges are installed",
+            required: false
+        })
+    };
+    static examples = [
+        "bitsocial challenge remove my-challenge",
+        "bitsocial challenge remove @scope/my-challenge"
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const dataPath = flags["pkcOptions.dataPath"] || defaults.PKC_DATA_PATH;
+        const challengesDir = getChallengesDir(dataPath);
+        const challengeDir = challengeNameToDir(challengesDir, args.name);
+        // Verify the challenge exists
+        try {
+            await fs.access(challengeDir);
+        }
+        catch {
+            this.error(`Challenge "${args.name}" is not installed.`);
+        }
+        // Remove the challenge directory
+        await fs.rm(challengeDir, { recursive: true, force: true });
+        // Clean up empty @scope/ dir for scoped packages
+        if (args.name.startsWith("@")) {
+            const scopeDir = path.dirname(challengeDir);
+            try {
+                const entries = await fs.readdir(scopeDir);
+                if (entries.length === 0) {
+                    await fs.rmdir(scopeDir);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.log(`Removed challenge '${args.name}'`);
+        // Best-effort reload via daemon
+        try {
+            await fetch("http://localhost:9138/api/challenges/reload", { method: "POST" });
+        }
+        catch {
+            // daemon not running, that's fine
+        }
+    }
+}

package/dist/cli/commands/community/create.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Create extends BaseCommand {
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        privateKeyPath: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/create.js

@@ -0,0 +1,54 @@
+import { Flags } from "@oclif/core";
+//@ts-ignore
+import DataObjectParser from "dataobject-parser";
+import fs from "fs";
+import { BaseCommand } from "../../base-command.js";
+import { getPKCLogger } from "../../../util.js";
+import * as remeda from "remeda";
+export default class Create extends BaseCommand {
+    static description = "Create a community with specific properties. A newly created community will be started after creation and be able to receive publications. For a list of properties, visit https://github.com/pkcprotocol/pkc-js";
+    static examples = [
+        {
+            description: "Create a community with title 'Hello Plebs' and description 'Welcome'",
+            command: "<%= config.bin %> <%= command.id %> --title 'Hello Plebs' --description 'Welcome'"
+        }
+    ];
+    static flags = {
+        privateKeyPath: Flags.file({
+            exists: true,
+            description: "Private key (PEM) of the community signer that will be used to determine address (if address is not a domain). If it's not provided then PKC will generate a private key"
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Create);
+        const log = (await getPKCLogger())("bitsocial-cli:commands:community:create");
+        log(`flags: `, flags);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        const createOptions = DataObjectParser.transpose(remeda.omit(flags, ["pkcRpcUrl", "privateKeyPath"]))["_data"];
+        if (flags.privateKeyPath)
+            try {
+                //@ts-expect-error
+                createOptions.signer = { privateKey: (await fs.promises.readFile(flags.privateKeyPath)).toString(), type: "ed25519" };
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(typeof e === "string" ? e : JSON.stringify(e));
+                //@ts-expect-error
+                error.details = { ...error.details, privateKeyPath: flags.privateKeyPath };
+                await pkc.destroy();
+                this.error(error);
+            }
+        try {
+            const createdCommunity = await pkc.createCommunity(createOptions);
+            await createdCommunity.start();
+            this.log(createdCommunity.address);
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(typeof e === "string" ? e : JSON.stringify(e));
+            //@ts-expect-error
+            error.details = { ...error.details, createOptions };
+            await pkc.destroy();
+            this.error(error);
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/delete.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Delete extends BaseCommand {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        addresses: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/delete.js

@@ -0,0 +1,44 @@
+import { getPKCLogger } from "../../../util.js";
+import { BaseCommand } from "../../base-command.js";
+import { Args } from "@oclif/core";
+export default class Delete extends BaseCommand {
+    static description = "Delete a community permanently.";
+    static strict = false; // To allow for variable length arguments
+    static args = {
+        addresses: Args.string({
+            name: "addresses",
+            required: true,
+            description: "Addresses of communities to delete. Separated by space"
+        })
+    };
+    static examples = [
+        "bitsocial community delete plebbit.bso",
+        "bitsocial community delete 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu"
+    ];
+    async run() {
+        const { argv, flags } = await this.parse(Delete);
+        const log = (await getPKCLogger())("bitsocial-cli:commands:community:delete");
+        log(`addresses: `, argv);
+        log(`flags: `, flags);
+        const addresses = argv;
+        if (!Array.isArray(addresses))
+            this.error(`Failed to parse addresses correctly (${addresses})`);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        for (const address of addresses) {
+            try {
+                const community = await pkc.createCommunity({ address });
+                await community.delete();
+                this.log(address);
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(typeof e === "string" ? e : JSON.stringify(e));
+                //@ts-expect-error
+                error.details = { ...error.details, address };
+                console.error(error);
+                await pkc.destroy();
+                this.exit(1);
+            }
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/edit.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Edit extends BaseCommand {
+    static description: string;
+    static args: {
+        address: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/edit.js

@@ -0,0 +1,74 @@
+//@ts-expect-error
+import DataObjectParser from "dataobject-parser";
+import { Args } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { getPKCLogger, mergeDeep } from "../../../util.js";
+import * as remeda from "remeda";
+export default class Edit extends BaseCommand {
+    static description = "Edit a community's properties. For a list of properties, visit https://github.com/pkcprotocol/pkc-js";
+    static args = {
+        address: Args.string({
+            name: "address",
+            required: true,
+            description: "Address of the community to edit"
+        })
+    };
+    static examples = [
+        {
+            description: "Change the address of the community to a new domain address",
+            command: "bitsocial community edit 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu --address newAddress.bso"
+        },
+        {
+            description: "Add the author address 'esteban.bso' as an admin on the community",
+            command: `bitsocial community edit mysub.bso '--roles["esteban.bso"].role' admin`
+        },
+        {
+            description: "Add two challenges to the community. The first challenge will be a question and answer, and the second will be an image captcha",
+            command: `bitsocial community edit mysub.bso --settings.challenges[0].name question --settings.challenges[0].options.question "what is the password?" --settings.challenges[0].options.answer thepassword --settings.challenges[1].name captcha-canvas-v3`
+        },
+        {
+            description: "Change the title and description",
+            command: `bitsocial community edit mysub.bso --title "This is the new title" --description "This is the new description" `
+        },
+        {
+            description: "Remove a role from a moderator/admin/owner",
+            command: "bitsocial community edit plebbit.bso --roles['rinse12.bso'] null"
+        },
+        {
+            description: "Enable settings.fetchThumbnailUrls to fetch the thumbnail of url submitted by authors",
+            command: "bitsocial community edit plebbit.bso --settings.fetchThumbnailUrls"
+        },
+        {
+            description: "disable settings.fetchThumbnailUrls",
+            command: "bitsocial community edit plebbit.bso --settings.fetchThumbnailUrls=false"
+        }
+    ];
+    async run() {
+        const { flags, args } = await this.parse(Edit);
+        const log = (await getPKCLogger())("bitsocial-cli:commands:community:edit");
+        log(`flags: `, flags);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        const editOptions = DataObjectParser.transpose(remeda.omit(flags, ["pkcRpcUrl"]))["_data"];
+        log("Edit options parsed:", editOptions);
+        const localCommunities = pkc.communities;
+        if (!localCommunities.includes(args.address))
+            this.error("Can't edit a remote community, make sure you're editing a local community");
+        try {
+            const community = await pkc.createCommunity({ address: args.address });
+            const mergedState = remeda.pick(community, remeda.keys.strict(editOptions));
+            const finalMergedState = mergeDeep(mergedState, editOptions);
+            log("Internal community state after merge:", finalMergedState);
+            await community.edit(finalMergedState);
+            this.log(community.address);
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(typeof e === "string" ? e : JSON.stringify(e));
+            //@ts-expect-error
+            error.details = { ...error.details, editOptions, address: args.address };
+            console.error(error);
+            await pkc.destroy();
+            this.exit(1);
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/get.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Get extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        address: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/get.js

@@ -0,0 +1,32 @@
+import { Args } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import * as remeda from "remeda";
+export default class Get extends BaseCommand {
+    static description = "Fetch a local or remote community, and print its json in the terminal";
+    static examples = [
+        "bitsocial community get plebmusic.bso",
+        "bitsocial community get 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu"
+    ];
+    static args = {
+        address: Args.string({
+            name: "address",
+            required: true,
+            description: "Address of the community to fetch"
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Get);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        try {
+            const community = await pkc.getCommunity({ address: args.address });
+            const communityJson = JSON.parse(JSON.stringify(community));
+            this.logJson({ posts: communityJson.posts, ...remeda.omit(communityJson, ["posts"]) }); // make sure posts is printed first, because most users won't look at it
+        }
+        catch (e) {
+            console.error(e);
+            await pkc.destroy();
+            this.exit(1);
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/list.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../../base-command.js";
+export default class List extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/list.js

@@ -0,0 +1,30 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { EOL } from "os";
+import { getPKCLogger } from "../../../util.js";
+import { printTable } from "@oclif/table";
+export default class List extends BaseCommand {
+    static description = "List your communities";
+    static examples = ["bitsocial community list -q", "bitsocial community list"];
+    static flags = {
+        quiet: Flags.boolean({ char: "q", summary: "Only display community addresses" })
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const log = (await getPKCLogger())("bitsocial-cli:commands:community:list");
+        log(`flags: `, flags);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        const communities = pkc.communities;
+        if (flags.quiet) {
+            this.log(communities.join(EOL));
+        }
+        else {
+            const communitiesWithStarted = await Promise.all(communities.map(async (address) => {
+                const community = await pkc.createCommunity({ address });
+                return { address: community.address, started: community.started };
+            }));
+            printTable({ data: communitiesWithStarted, sort: { started: "desc" } });
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/start.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Start extends BaseCommand {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        addresses: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static examples: (string | {
+        description: string;
+        command: string;
+    })[];
+    run(): Promise<void>;
+}

package/dist/cli/commands/community/start.js

@@ -0,0 +1,46 @@
+import { getPKCLogger } from "../../../util.js";
+import { BaseCommand } from "../../base-command.js";
+import { Args } from "@oclif/core";
+export default class Start extends BaseCommand {
+    static description = "Start a community";
+    static strict = false; // To allow for variable length arguments
+    static args = {
+        addresses: Args.string({
+            name: "addresses", // name of arg to show in help and reference with args[name]
+            required: true,
+            description: "Addresses of communities to start. Separated by space"
+        })
+    };
+    static examples = [
+        "bitsocial community start plebbit.bso",
+        "bitsocial community start 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu",
+        {
+            description: "Start all communities in your data path",
+            command: "bitsocial community start $(bitsocial community list -q)"
+        }
+    ];
+    async run() {
+        const { argv, flags } = await this.parse(Start);
+        const addresses = argv;
+        const log = (await getPKCLogger())("bitsocial-cli:commands:community:start");
+        log(`addresses: `, addresses);
+        log(`flags: `, flags);
+        const pkc = await this._connectToPkcRpc(flags.pkcRpcUrl.toString());
+        for (const address of addresses) {
+            try {
+                const community = await pkc.createCommunity({ address });
+                await community.start();
+                this.log(address);
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(typeof e === "string" ? e : JSON.stringify(e));
+                //@ts-expect-error
+                error.details = { ...error.details, address };
+                console.error(error);
+                await pkc.destroy();
+                this.exit(1);
+            }
+        }
+        await pkc.destroy();
+    }
+}

package/dist/cli/commands/community/stop.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../../base-command.js";
+export default class Stop extends BaseCommand {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        addresses: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}