@bitsocial/bitsocial-cli 0.19.39

package/dist/cli/commands/logs.js

@@ -0,0 +1,199 @@
+import { Flags, Command } from "@oclif/core";
+import defaults from "../../common-utils/defaults.js";
+import fs from "fs";
+import fsPromise from "fs/promises";
+import path from "path";
+export default class Logs extends Command {
+    static description = "View the latest BitSocial daemon log file. By default dumps the full log and exits. Use --follow to stream new output in real-time (like tail -f).";
+    static flags = {
+        follow: Flags.boolean({
+            char: "f",
+            description: "Follow log output in real-time (like tail -f)",
+            default: false
+        }),
+        tail: Flags.string({
+            char: "n",
+            description: 'Number of log entries to show from the end. Use "all" to show everything.',
+            default: "all"
+        }),
+        since: Flags.string({
+            description: "Show logs since timestamp (ISO 8601, e.g. 2026-01-02T13:23:37Z) or relative time (e.g. 30s, 42m, 2h, 1d)",
+            required: false
+        }),
+        until: Flags.string({
+            description: "Show logs before timestamp (ISO 8601, e.g. 2026-01-02T13:23:37Z) or relative time (e.g. 30s, 42m, 2h, 1d)",
+            required: false
+        }),
+        logPath: Flags.directory({
+            description: "Specify the directory containing log files",
+            required: false
+        })
+    };
+    static examples = [
+        "bitsocial logs",
+        "bitsocial logs -f",
+        "bitsocial logs -n 50",
+        "bitsocial logs --since 5m",
+        "bitsocial logs --since 2026-01-02T13:23:37Z --until 2026-01-02T14:00:00Z",
+        "bitsocial logs --since 1h -f"
+    ];
+    async _findLatestLogFile(logPath) {
+        let entries;
+        try {
+            entries = await fsPromise.readdir(logPath, { withFileTypes: true });
+        }
+        catch {
+            this.error(`Log directory does not exist: ${logPath}\nHave you started the daemon yet?`);
+        }
+        const logFiles = entries
+            .filter((entry) => entry.isFile() && entry.name.startsWith("bitsocial_cli_daemon_") && entry.name.endsWith(".log"))
+            .map((entry) => entry.name)
+            .sort();
+        if (logFiles.length === 0) {
+            this.error(`No log files found in ${logPath}\nHave you started the daemon yet?`);
+        }
+        return path.join(logPath, logFiles[logFiles.length - 1]);
+    }
+    _parseTimestamp(value) {
+        // Try relative duration first: 30s, 42m, 2h, 1d
+        const relativeMatch = value.match(/^(\d+)([smhd])$/);
+        if (relativeMatch) {
+            const amount = parseInt(relativeMatch[1], 10);
+            const unit = relativeMatch[2];
+            const multipliers = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+            return new Date(Date.now() - amount * multipliers[unit]);
+        }
+        // Try ISO timestamp
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+            this.error(`Invalid timestamp: "${value}". Use ISO 8601 format (e.g. 2026-01-02T13:23:37Z) or relative time (e.g. 30s, 42m, 2h, 1d)`);
+        }
+        return date;
+    }
+    _extractTimestamp(line) {
+        const match = line.match(/^\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\] /);
+        if (!match)
+            return null;
+        return new Date(match[1]);
+    }
+    _parseLogEntries(content) {
+        const lines = content.split("\n");
+        const entries = [];
+        for (const line of lines) {
+            const timestamp = this._extractTimestamp(line);
+            if (timestamp !== null) {
+                // New timestamped entry
+                entries.push({ timestamp, lines: [line] });
+            }
+            else if (entries.length > 0) {
+                // Continuation line — belongs to the previous entry
+                entries[entries.length - 1].lines.push(line);
+            }
+            else {
+                // Line before any timestamped entry (legacy/header)
+                entries.push({ timestamp: null, lines: [line] });
+            }
+        }
+        return entries;
+    }
+    _filterEntries(entries, since, until) {
+        return entries.filter((entry) => {
+            if (entry.timestamp === null) {
+                // Legacy entries with no timestamp: exclude if --since is set, include otherwise
+                return !since;
+            }
+            if (since && entry.timestamp < since)
+                return false;
+            if (until && entry.timestamp > until)
+                return false;
+            return true;
+        });
+    }
+    _tailEntries(entries, tailValue) {
+        if (tailValue === "all")
+            return entries;
+        const n = parseInt(tailValue, 10);
+        if (isNaN(n) || n < 0) {
+            this.error(`Invalid --tail value: "${tailValue}". Must be a non-negative integer or "all".`);
+        }
+        if (n === 0)
+            return [];
+        return entries.slice(-n);
+    }
+    async run() {
+        const { flags } = await this.parse(Logs);
+        const logPath = flags.logPath ?? defaults.PKC_LOG_PATH;
+        const latestLogFile = await this._findLatestLogFile(logPath);
+        const since = flags.since ? this._parseTimestamp(flags.since) : undefined;
+        const until = flags.until ? this._parseTimestamp(flags.until) : undefined;
+        if (!flags.follow) {
+            const content = await fsPromise.readFile(latestLogFile, "utf-8");
+            const entries = this._parseLogEntries(content);
+            const filtered = this._filterEntries(entries, since, until);
+            const tailed = this._tailEntries(filtered, flags.tail);
+            const output = tailed.map((e) => e.lines.join("\n")).join("\n");
+            if (output)
+                process.stdout.write(output + "\n");
+            return;
+        }
+        // Follow mode: dump existing content (filtered + tailed) then watch for new data
+        const existingContent = await fsPromise.readFile(latestLogFile, "utf-8");
+        const entries = this._parseLogEntries(existingContent);
+        const filtered = this._filterEntries(entries, since, until);
+        const tailed = this._tailEntries(filtered, flags.tail);
+        const initialOutput = tailed.map((e) => e.lines.join("\n")).join("\n");
+        if (initialOutput)
+            process.stdout.write(initialOutput + "\n");
+        const stat = await fsPromise.stat(latestLogFile);
+        let position = stat.size;
+        let pendingBuffer = "";
+        // Watch for new data using polling (works across filesystems including Docker volumes)
+        const readNewData = async () => {
+            try {
+                const currentStat = await fsPromise.stat(latestLogFile);
+                if (currentStat.size > position) {
+                    const fd = await fsPromise.open(latestLogFile, "r");
+                    const buf = new Uint8Array(currentStat.size - position);
+                    const { bytesRead } = await fd.read(buf, 0, buf.length, position);
+                    await fd.close();
+                    position += bytesRead;
+                    const chunk = pendingBuffer + new TextDecoder().decode(buf.subarray(0, bytesRead));
+                    // Split into complete lines; keep any incomplete trailing line in the buffer
+                    const lastNewline = chunk.lastIndexOf("\n");
+                    if (lastNewline === -1) {
+                        pendingBuffer = chunk;
+                        return;
+                    }
+                    pendingBuffer = chunk.slice(lastNewline + 1);
+                    const completeText = chunk.slice(0, lastNewline + 1);
+                    if (!since && !until) {
+                        // No time filtering — pass through directly
+                        process.stdout.write(completeText);
+                    }
+                    else {
+                        const newEntries = this._parseLogEntries(completeText.replace(/\n$/, ""));
+                        const filteredNew = this._filterEntries(newEntries, since, until);
+                        const output = filteredNew.map((e) => e.lines.join("\n")).join("\n");
+                        if (output)
+                            process.stdout.write(output + "\n");
+                    }
+                }
+            }
+            catch {
+                // File may have been rotated or deleted
+            }
+        };
+        fs.watchFile(latestLogFile, { interval: 300 }, readNewData);
+        // Keep the process alive and clean up on exit
+        process.on("SIGINT", () => {
+            fs.unwatchFile(latestLogFile, readNewData);
+            process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+            fs.unwatchFile(latestLogFile, readNewData);
+            process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+}

package/dist/cli/commands/subplebbit/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/subplebbit/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 { getPlebbitLogger } from "../../../util.js";
+import * as remeda from "remeda";
+export default class Create extends BaseCommand {
+    static description = "Create a subplebbit with specific properties. A newly created sub will be started after creation and be able to receive publications. For a list of properties, visit https://github.com/plebbit/plebbit-js#subplebbiteditsubplebbiteditoptions";
+    static examples = [
+        {
+            description: "Create a subplebbit 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 subplebbit signer that will be used to determine address (if address is not a domain). If it's not provided then Plebbit will generate a private key"
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Create);
+        const log = (await getPlebbitLogger())("plebbit-cli:commands:subplebbit:create");
+        log(`flags: `, flags);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        const createOptions = DataObjectParser.transpose(remeda.omit(flags, ["plebbitRpcUrl", "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;
+                //@ts-expect-error
+                error.details = { ...error.details, privateKeyPath: flags.privateKeyPath };
+                await plebbit.destroy();
+                this.error(error);
+            }
+        try {
+            const createdSub = await plebbit.createSubplebbit(createOptions);
+            await createdSub.start();
+            this.log(createdSub.address);
+        }
+        catch (e) {
+            const error = e;
+            //@ts-expect-error
+            error.details = { ...error.details, createOptions };
+            await plebbit.destroy();
+            this.error(error);
+        }
+        await plebbit.destroy();
+    }
+}

package/dist/cli/commands/subplebbit/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/subplebbit/edit.js

@@ -0,0 +1,73 @@
+//@ts-expect-error
+import DataObjectParser from "dataobject-parser";
+import { Args } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { getPlebbitLogger, mergeDeep } from "../../../util.js";
+import * as remeda from "remeda";
+export default class Edit extends BaseCommand {
+    static description = "Edit a subplebbit properties. For a list of properties, visit https://github.com/plebbit/plebbit-js#subplebbiteditsubplebbiteditoptions";
+    static args = {
+        address: Args.string({
+            name: "address",
+            required: true,
+            description: "Address of the subplebbit address to edit"
+        })
+    };
+    static examples = [
+        {
+            description: "Change the address of the sub to a new ENS address",
+            command: "plebbit subplebbit edit 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu --address newAddress.eth"
+        },
+        {
+            description: "Add the author address 'esteban.eth' as an admin on the sub",
+            command: `plebbit subplebbit edit mysub.eth '--roles["esteban.eth"].role' admin`
+        },
+        {
+            description: "Add two challenges to the sub. The first challenge will be a question and answer, and the second will be an image captcha",
+            command: `plebbit subplebbit edit mysub.eth --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: `plebbit subplebbit edit mysub.eth --title "This is the new title" --description "This is the new description" `
+        },
+        {
+            description: "Remove a role from a moderator/admin/owner",
+            command: "plebbit subplebbit edit plebbit.eth --roles['rinse12.eth'] null"
+        },
+        {
+            description: "Enable settings.fetchThumbnailUrls to fetch the thumbnail of url submitted by authors",
+            command: "subplebbit edit plebbit.eth --settings.fetchThumbnailUrls"
+        },
+        {
+            description: "disable settings.fetchThumbnailUrls",
+            command: "subplebbit edit plebbit.eth --settings.fetchThumbnailUrls=false"
+        }
+    ];
+    async run() {
+        const { flags, args } = await this.parse(Edit);
+        const log = (await getPlebbitLogger())("plebbit-cli:commands:subplebbit:edit");
+        log(`flags: `, flags);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        const editOptions = DataObjectParser.transpose(remeda.omit(flags, ["plebbitRpcUrl"]))["_data"];
+        log("Edit options parsed:", editOptions);
+        const localSubs = plebbit.subplebbits;
+        if (!localSubs.includes(args.address))
+            this.error("Can't edit a remote subplebbit, make sure you're editing a local sub");
+        try {
+            const sub = await plebbit.createSubplebbit({ address: args.address });
+            const mergedSubState = remeda.pick(sub, remeda.keys.strict(editOptions));
+            const finalMergedState = mergeDeep(mergedSubState, editOptions);
+            log("Internal sub state after merge:", finalMergedState);
+            await sub.edit(finalMergedState);
+            this.log(sub.address);
+        }
+        catch (e) {
+            //@ts-expect-error
+            e.details = { ...e.details, editOptions, address: args.address };
+            console.error(e);
+            await plebbit.destroy();
+            this.exit(1);
+        }
+        await plebbit.destroy();
+    }
+}

package/dist/cli/commands/subplebbit/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/subplebbit/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 subplebbit, and print its json in the terminal";
+    static examples = [
+        "plebbit subplebbit get plebmusic.eth",
+        "plebbit subplebbit get 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu"
+    ];
+    static args = {
+        address: Args.string({
+            name: "address",
+            required: true,
+            description: "Address of the subplebbit address to fetch"
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Get);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        try {
+            const sub = await plebbit.getSubplebbit({ address: args.address });
+            const subJson = JSON.parse(JSON.stringify(sub));
+            this.logJson({ posts: subJson.posts, ...remeda.omit(subJson, ["posts"]) }); // make sure posts is printed first, because most users won't look at it
+        }
+        catch (e) {
+            console.error(e);
+            await plebbit.destroy();
+            this.exit(1);
+        }
+        await plebbit.destroy();
+    }
+}

package/dist/cli/commands/subplebbit/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/subplebbit/list.js

@@ -0,0 +1,30 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { EOL } from "os";
+import { getPlebbitLogger } from "../../../util.js";
+import { printTable } from "@oclif/table";
+export default class List extends BaseCommand {
+    static description = "List your subplebbits";
+    static examples = ["plebbit subplebbit list -q", "plebbit subplebbit list"];
+    static flags = {
+        quiet: Flags.boolean({ char: "q", summary: "Only display subplebbit addresses" })
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const log = (await getPlebbitLogger())("plebbit-cli:commands:subplebbit:list");
+        log(`flags: `, flags);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        const subs = plebbit.subplebbits;
+        if (flags.quiet) {
+            this.log(subs.join(EOL));
+        }
+        else {
+            const subsWithStarted = await Promise.all(subs.map(async (subAddress) => {
+                const subInstance = await plebbit.createSubplebbit({ address: subAddress });
+                return { address: subInstance.address, started: subInstance.started };
+            }));
+            printTable({ data: subsWithStarted, sort: { started: "desc" } });
+        }
+        await plebbit.destroy();
+    }
+}

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

@@ -0,0 +1,10 @@
+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[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { getPlebbitLogger } from "../../../util.js";
+import { BaseCommand } from "../../base-command.js";
+import { Args } from "@oclif/core";
+export default class Start extends BaseCommand {
+    static description = "Start a subplebbit";
+    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 subplebbits to start. Separated by space"
+        })
+    };
+    static examples = [
+        "plebbit subplebbit start plebbit.eth",
+        "plebbit subplebbit start 12D3KooWG3XbzoVyAE6Y9vHZKF64Yuuu4TjdgQKedk14iYmTEPWu"
+    ];
+    async run() {
+        const { argv, flags } = await this.parse(Start);
+        const addresses = argv;
+        const log = (await getPlebbitLogger())("plebbit-cli:commands:subplebbit:start");
+        log(`addresses: `, addresses);
+        log(`flags: `, flags);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        for (const address of addresses) {
+            try {
+                const sub = await plebbit.createSubplebbit({ address });
+                await sub.start();
+                this.log(address);
+            }
+            catch (e) {
+                //@ts-expect-error
+                e.details = { ...e.details, address };
+                console.error(e);
+                await plebbit.destroy();
+                this.exit(1);
+            }
+        }
+        await plebbit.destroy();
+    }
+}

package/dist/cli/commands/subplebbit/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>;
+}

package/dist/cli/commands/subplebbit/stop.js

@@ -0,0 +1,43 @@
+import { getPlebbitLogger } from "../../../util.js";
+import { BaseCommand } from "../../base-command.js";
+import { Args } from "@oclif/core";
+export default class Stop extends BaseCommand {
+    static description = "Stop a subplebbit. The subplebbit will not publish or receive any publications until it is started again.";
+    static strict = false; // To allow for variable length arguments
+    static args = {
+        addresses: Args.string({
+            name: "addresses",
+            required: true,
+            description: "Addresses of subplebbits to stop. Separated by space"
+        })
+    };
+    static examples = [
+        "plebbit subplebbit stop plebbit.eth",
+        "plebbit subplebbit stop Qmb99crTbSUfKXamXwZBe829Vf6w5w5TktPkb6WstC9RFW"
+    ];
+    async run() {
+        const { argv, flags } = await this.parse(Stop);
+        const log = (await getPlebbitLogger())("plebbit-cli:commands:subplebbit:stop");
+        log(`addresses: `, argv);
+        log(`flags: `, flags);
+        const addresses = argv;
+        if (!Array.isArray(addresses))
+            this.error(`Failed to parse addresses correctly (${addresses})`);
+        const plebbit = await this._connectToPlebbitRpc(flags.plebbitRpcUrl.toString());
+        for (const address of addresses) {
+            try {
+                const sub = await plebbit.createSubplebbit({ address });
+                await sub.stop(); // should stop the original subplebbit instance from running
+                this.log(address);
+            }
+            catch (e) {
+                //@ts-expect-error
+                e.details = { ...e.details, address };
+                console.error(e);
+                await plebbit.destroy();
+                this.exit(1);
+            }
+        }
+        await plebbit.destroy();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Command } from "@oclif/core";
+export default class Check extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,28 @@
+import { Command } from "@oclif/core";
+import { fetchLatestVersion } from "../../../update/npm-registry.js";
+import { compareVersions } from "../../../update/semver.js";
+export default class Check extends Command {
+    static description = "Check if a newer version of bitsocial is available on npm";
+    static examples = ["bitsocial update check"];
+    async run() {
+        let latest;
+        try {
+            latest = await fetchLatestVersion();
+        }
+        catch (err) {
+            this.error(`Failed to check for updates: ${err.message}`, { exit: 1 });
+        }
+        const current = this.config.version;
+        const cmp = compareVersions(current, latest);
+        if (cmp === 0) {
+            this.log(`bitsocial is up-to-date: v${current}`);
+        }
+        else if (cmp < 0) {
+            this.log(`Update available: v${latest} (current: v${current})`);
+            this.log(`Run: bitsocial update install`);
+        }
+        else {
+            this.log(`bitsocial v${current} is newer than latest published release v${latest}`);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from "@oclif/core";
+export default class Install extends Command {
+    static description: string;
+    static args: {
+        version: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,63 @@
+import { Args, Flags, Command } from "@oclif/core";
+import tcpPortUsed from "tcp-port-used";
+import defaults from "../../../common-utils/defaults.js";
+import { fetchLatestVersion, installGlobal } from "../../../update/npm-registry.js";
+import { compareVersions } from "../../../update/semver.js";
+export default class Install extends Command {
+    static description = "Install a specific version of bitsocial from npm";
+    static args = {
+        version: Args.string({
+            description: 'Version to install (e.g. "0.19.40" or "latest")',
+            required: false,
+            default: "latest"
+        })
+    };
+    static flags = {
+        force: Flags.boolean({
+            description: "Reinstall even if already on the requested version",
+            default: false
+        })
+    };
+    static examples = [
+        "bitsocial update install",
+        "bitsocial update install latest",
+        "bitsocial update install 0.19.40",
+        "bitsocial update install --force"
+    ];
+    async run() {
+        const { args, flags } = await this.parse(Install);
+        // Check if daemon is running — refuse to update while it's active
+        const rpcPort = Number(defaults.PKC_RPC_URL.port);
+        const daemonRunning = await tcpPortUsed.check(rpcPort, "127.0.0.1").catch(() => false);
+        if (daemonRunning) {
+            this.error(`Daemon is running on port ${rpcPort}. Stop it first with Ctrl-C, then run 'bitsocial update install'.`, { exit: 1 });
+        }
+        // Resolve the target version
+        let targetVersion;
+        if (!args.version || args.version === "latest") {
+            try {
+                targetVersion = await fetchLatestVersion();
+            }
+            catch (err) {
+                this.error(`Failed to fetch latest version: ${err.message}`, { exit: 1 });
+            }
+        }
+        else {
+            targetVersion = args.version.replace(/^v/i, "");
+        }
+        const current = this.config.version;
+        // Skip if already on this version (unless --force)
+        if (compareVersions(current, targetVersion) === 0 && !flags.force) {
+            this.log(`Already on v${current}. Use --force to reinstall.`);
+            return;
+        }
+        this.log(`Installing bitsocial-cli@${targetVersion}...`);
+        try {
+            await installGlobal(targetVersion);
+        }
+        catch (err) {
+            this.error(`Update failed: ${err.message}`, { exit: 1 });
+        }
+        this.log(`Installed bitsocial v${targetVersion} (was v${current}).`);
+    }
+}