bsv-pay-cli 0.2.0

package/dist/chain/whatsonchain.js

@@ -0,0 +1,98 @@
+import { networkError } from '../errors.js';
+const REQUEST_TIMEOUT_MS = 15_000;
+const RETRY_DELAY_MS = 1_500;
+const RATE_LIMIT_DELAY_MS = 3_000;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+export class WhatsOnChainProvider {
+    network;
+    baseUrl;
+    constructor(network) {
+        this.network = network;
+        // BSV_PAY_API_URL points at any WhatsOnChain-compatible API root
+        // (self-hosted instance, or the local e2e mock server).
+        const root = process.env.BSV_PAY_API_URL ?? 'https://api.whatsonchain.com/v1/bsv';
+        this.baseUrl = `${root.replace(/\/$/, '')}/${network}`;
+    }
+    /**
+     * GET with one automatic retry (invariant 5). 429s wait longer before the
+     * retry; persistent failure is exit 4.
+     */
+    async get(path) {
+        const url = this.baseUrl + path;
+        let lastError = '';
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const res = await fetch(url, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+                if (res.ok)
+                    return await res.text();
+                lastError = `HTTP ${res.status}`;
+                if (res.status === 404)
+                    break; // not retryable
+                await sleep(res.status === 429 ? RATE_LIMIT_DELAY_MS : RETRY_DELAY_MS);
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e.message : String(e);
+                if (attempt === 0)
+                    await sleep(RETRY_DELAY_MS);
+            }
+        }
+        throw networkError(`WhatsOnChain request failed (${lastError}) for ${url}. Check your connection and retry; the API may be briefly rate-limiting.`);
+    }
+    async getJson(path) {
+        const body = await this.get(path);
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            throw networkError(`WhatsOnChain returned unparseable JSON for ${path}. Retry shortly.`);
+        }
+    }
+    async getBalance(address) {
+        return this.getJson(`/address/${address}/balance`);
+    }
+    async getUtxos(address) {
+        const rows = await this.getJson(`/address/${address}/unspent`);
+        return rows.map((r) => ({
+            txid: r.tx_hash,
+            vout: r.tx_pos,
+            satoshis: r.value,
+            height: r.height > 0 ? r.height : undefined,
+        }));
+    }
+    async getHistory(address) {
+        const rows = await this.getJson(`/address/${address}/history`);
+        return rows.map((r) => ({ txid: r.tx_hash, height: r.height }));
+    }
+    async getRawTx(txid) {
+        return (await this.get(`/tx/${txid}/hex`)).trim();
+    }
+    /**
+     * Broadcast is NOT silently retried: a retry after an ambiguous failure
+     * could double-report. A definitive API rejection returns ok=false; an
+     * ambiguous network failure throws (caller maps to exit 6, status unknown).
+     */
+    async broadcast(rawTxHex) {
+        const url = `${this.baseUrl}/tx/raw`;
+        let res;
+        try {
+            res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ txhex: rawTxHex }),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (e) {
+            throw networkError(`Broadcast request did not complete (${e instanceof Error ? e.message : String(e)}). The transaction may or may not have propagated.`);
+        }
+        const body = (await res.text()).trim();
+        if (res.ok) {
+            // WoC returns the txid as a JSON string
+            const txid = body.replace(/^"|"$/g, '');
+            return { ok: true, txid };
+        }
+        return { ok: false, error: body || `HTTP ${res.status}` };
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { Command, CommanderError } from 'commander';
+import { buildCtx } from './context.js';
+import { EXIT } from './errors.js';
+import { Output } from './output.js';
+import { cmdInit } from './commands/init.js';
+import { cmdBalance } from './commands/balance.js';
+import { cmdSend } from './commands/send.js';
+import { cmdRequest } from './commands/request.js';
+import { cmdWatch } from './commands/watch.js';
+import { cmdDonate } from './commands/donate.js';
+import { cmdFetch } from './commands/fetch.js';
+import { cmdMcp } from './commands/mcp.js';
+import { cmdPolicyShow, cmdPolicyTest } from './commands/policy.js';
+import { cmdServe } from './commands/serve.js';
+import { cmdApprovalsApprove, cmdApprovalsList, cmdApprovalsReject, cmdApprovalsSetSecret, } from './commands/approvals.js';
+const program = new Command();
+/** Wrap a command action: build context, map errors to exit codes + JSON. */
+function run(fn) {
+    return async (...cmdArgs) => {
+        // Commander passes (...args, options, command); we use optsWithGlobals.
+        const command = cmdArgs[cmdArgs.length - 1];
+        const opts = command.optsWithGlobals();
+        let ctx;
+        try {
+            ctx = buildCtx(opts);
+            // keep positional args + the options object, drop the trailing Command
+            await fn(ctx, ...cmdArgs.slice(0, -1));
+            process.exitCode = EXIT.OK;
+        }
+        catch (err) {
+            const out = ctx?.out ?? new Output(Boolean(opts.json));
+            process.exitCode = out.error(err);
+        }
+    };
+}
+program
+    .name('bsv-pay')
+    .description('Send and receive Bitcoin SV micropayments from the command line')
+    .version('0.2.0')
+    .option('--json', 'machine-readable JSON output (NDJSON for watch)')
+    .option('--testnet', 'use BSV testnet (state kept separate from mainnet)');
+program
+    .command('init')
+    .description('Create or import a wallet')
+    .option('--import-seed', 'import an existing BIP-39 seed phrase')
+    .option('--import-wif', 'import a raw WIF private key (not recommended)')
+    .option('--force', 'overwrite an existing wallet')
+    .option('--no-encrypt', 'EXPLICIT OPT-IN: store the seed unencrypted (dangerous)')
+    .option('--brc100', 'connect a BRC-100 wallet (see --experimental-brc100)')
+    .option('--experimental-brc100', 'EXPERIMENTAL: delegate custody to a BRC-100 wallet app (keys never leave it)')
+    .action(run((ctx, opts) => cmdInit(ctx, opts)));
+program
+    .command('balance')
+    .description('Show confirmed and unconfirmed balance across all tracked addresses')
+    .action(run((ctx) => cmdBalance(ctx)));
+program
+    .command('send')
+    .description('Send satoshis to an address')
+    .argument('<address>', 'recipient BSV address')
+    .argument('<amount>', 'amount: bare satoshis, Nsats, or Nbsv')
+    .argument('[memo]', 'local-only memo for your ledger (never written on-chain)')
+    .option('-y, --yes', 'skip the confirmation prompt (spend limit still enforced)')
+    .option('--allow-large', 'with --yes, permit sends at/above the spend limit')
+    .option('--dry-run', 'build and display the transaction but never broadcast')
+    .option('--confirmed-only', 'spend only confirmed UTXOs')
+    .action(run((ctx, address, amount, memo, opts) => cmdSend(ctx, address, amount, memo, opts)));
+program
+    .command('request')
+    .description('Create a payment request with a fresh address, URI, and QR code')
+    .argument('<amount>', 'amount: bare satoshis, Nsats, or Nbsv')
+    .argument('[memo]', 'local-only memo / request label')
+    .option('--wait', 'poll until the payment is seen (0-conf), then exit 0')
+    .option('--timeout <sec>', 'with --wait, give up after this many seconds', '600')
+    .action(run((ctx, amount, memo, opts) => cmdRequest(ctx, amount, memo, opts)));
+program
+    .command('watch')
+    .description('Watch all tracked addresses for incoming payments')
+    .option('--interval <sec>', 'poll interval in seconds (floor 5)')
+    .action(run((ctx, opts) => cmdWatch(ctx, opts)));
+program
+    .command('donate')
+    .description('Support bsv-pay development')
+    .argument('[amount]', 'amount to donate (default 10000 sats)')
+    .option('-y, --yes', 'skip the confirmation prompt')
+    .option('--allow-large', 'with --yes, permit sends at/above the spend limit')
+    .option('--dry-run', 'build and display the transaction but never broadcast')
+    .action(run((ctx, amount, opts) => cmdDonate(ctx, amount, opts)));
+program
+    .command('fetch')
+    .description('Fetch a URL, automatically paying a BRC-105 402 paywall within policy')
+    .argument('<url>', 'http(s) URL to fetch')
+    .option('--max-price <amount>', 'refuse to pay more than this for the resource')
+    .action(run((ctx, url, opts) => cmdFetch(ctx, url, opts)));
+program
+    .command('serve')
+    .description('Run a demo BRC-105 paywall server: each request pays --price into this wallet')
+    .requiredOption('--price <amount>', 'price per request: bare satoshis, Nsats, or Nbsv')
+    .option('--port <n>', 'port to listen on', '8402')
+    .option('--host <host>', 'interface to bind (default localhost-only)', '127.0.0.1')
+    .option('--body <text>', 'content to serve once paid')
+    .action(run((ctx, opts) => cmdServe(ctx, opts)));
+program
+    .command('mcp')
+    .description('Serve MCP tools over stdio for AI agents (wallet unlocks at start; policy enforced in core)')
+    .action(run((ctx) => cmdMcp(ctx)));
+const policy = program
+    .command('policy')
+    .description('Inspect and dry-run the spend policy (~/.bsv-pay/policy.toml)');
+policy
+    .command('show')
+    .description('Show active policy rules, current budget usage, and pending approvals')
+    .action(run((ctx) => Promise.resolve(cmdPolicyShow(ctx))));
+policy
+    .command('test')
+    .description('Dry-run a policy decision: exit 0 allow, 8 deny, 9 would-queue')
+    .argument('<address>', 'recipient BSV address')
+    .argument('<amount>', 'amount: bare satoshis, Nsats, or Nbsv')
+    .action(run((ctx, address, amount) => Promise.resolve(cmdPolicyTest(ctx, address, amount))));
+const approvals = program
+    .command('approvals')
+    .description('Review and resolve payments queued by approval_threshold_sats');
+approvals
+    .command('list')
+    .description('List payments waiting for human approval')
+    .action(run((ctx) => Promise.resolve(cmdApprovalsList(ctx))));
+approvals
+    .command('approve')
+    .description('Approve and send a queued payment (interactive: approval secret required)')
+    .argument('<id>', 'approval id (or unambiguous prefix) from "approvals list"')
+    .action(run((ctx, id) => cmdApprovalsApprove(ctx, id)));
+approvals
+    .command('reject')
+    .description('Reject a queued payment (interactive: approval secret required)')
+    .argument('<id>', 'approval id (or unambiguous prefix) from "approvals list"')
+    .action(run((ctx, id) => cmdApprovalsReject(ctx, id)));
+approvals
+    .command('set-secret')
+    .description('Set or change the human approval secret (interactive only, by design)')
+    .action(run((ctx) => cmdApprovalsSetSecret(ctx)));
+program.exitOverride();
+try {
+    await program.parseAsync(process.argv);
+}
+catch (err) {
+    if (err instanceof CommanderError) {
+        // help/version display are success; everything else is invalid usage.
+        if (err.code === 'commander.helpDisplayed' ||
+            err.code === 'commander.version' ||
+            err.code === 'commander.help') {
+            process.exitCode = err.exitCode === 0 ? EXIT.OK : EXIT.USAGE;
+        }
+        else {
+            const json = process.argv.includes('--json');
+            if (json) {
+                process.stdout.write(JSON.stringify({
+                    ok: false,
+                    code: EXIT.USAGE,
+                    error: 'invalid_usage',
+                    message: err.message,
+                }) + '\n');
+            }
+            process.exitCode = EXIT.USAGE;
+        }
+    }
+    else {
+        process.exitCode = new Output(process.argv.includes('--json')).error(err);
+    }
+}

package/dist/commands/approvals.d.ts

@@ -0,0 +1,19 @@
+import type { ChainProvider } from '../chain/provider.js';
+import type { Ctx } from '../context.js';
+/**
+ * Test seam ONLY: lets unit tests inject the hidden prompts. There is no
+ * CLI flag, env var, or config key that reaches these — the cli.ts wiring
+ * never passes them, so the only way to supply a secret to the real binary
+ * is typing it at a TTY.
+ */
+export interface ApprovalPromptDeps {
+    promptSecret?: () => Promise<string>;
+}
+export declare function cmdApprovalsList(ctx: Ctx): void;
+export declare function cmdApprovalsApprove(ctx: Ctx, id: string, provider?: ChainProvider, deps?: ApprovalPromptDeps): Promise<void>;
+export declare function cmdApprovalsReject(ctx: Ctx, id: string, deps?: ApprovalPromptDeps): Promise<void>;
+export interface SetSecretPromptDeps {
+    promptOldSecret?: () => Promise<string>;
+    promptNewSecret?: () => Promise<string>;
+}
+export declare function cmdApprovalsSetSecret(ctx: Ctx, deps?: SetSecretPromptDeps): Promise<void>;

package/dist/commands/approvals.js

@@ -0,0 +1,112 @@
+import chalk from 'chalk';
+import { executeSend, planApprovedSend } from '../core/send.js';
+import { openWallet } from '../core/wallet.js';
+import { usageError } from '../errors.js';
+import { approvalSecretConfigured, badApprovalSecret, findPendingApproval, listPendingApprovals, resolveApproval, storeApprovalSecret, verifyApprovalSecret, } from '../policy/approvals.js';
+import { askHidden, isInteractive } from '../prompt.js';
+import { formatSats } from '../units.js';
+import { obtainPassphrase } from '../wallet/wallet.js';
+/** Approval verbs are human-only: a piped/agent shell has no TTY and stops here. */
+function requireTty(action) {
+    if (!isInteractive()) {
+        throw usageError('tty_required', `${action} requires an interactive terminal. There is deliberately no flag or environment variable for it — a human must type the approval secret.`);
+    }
+}
+async function requireApprovalSecret(deps) {
+    if (!approvalSecretConfigured()) {
+        throw usageError('approval_secret_missing', 'No approval secret is set. A human must run "bsv-pay approvals set-secret" (interactive) before queued payments can be approved or rejected.');
+    }
+    const prompt = deps?.promptSecret ?? (() => askHidden('Approval secret: '));
+    const secret = await prompt();
+    if (!verifyApprovalSecret(secret))
+        throw badApprovalSecret();
+}
+export function cmdApprovalsList(ctx) {
+    const pending = listPendingApprovals(ctx.network);
+    if (pending.length === 0) {
+        ctx.out.info('No pending approvals.');
+    }
+    else {
+        ctx.out.info(chalk.bold(`Pending approvals (${ctx.network === 'test' ? 'testnet' : 'mainnet'})`));
+        for (const p of pending) {
+            ctx.out.info(`  ${p.approvalId.slice(0, 8)}  ${formatSats(p.amountSats)}  -> ${p.address}` +
+                `${p.memo ? `  "${p.memo}"` : ''}  (queued ${p.queuedAt})`);
+        }
+        ctx.out.info('');
+        ctx.out.info('Approve with: bsv-pay approvals approve <id>   (requires the approval secret)');
+    }
+    ctx.out.result({
+        ok: true,
+        approvals: pending.map((p) => ({
+            id: p.approvalId,
+            address: p.address,
+            amount_sats: p.amountSats,
+            ...(p.memo ? { memo: p.memo } : {}),
+            queued_at: p.queuedAt,
+        })),
+    });
+}
+export async function cmdApprovalsApprove(ctx, id, provider, deps) {
+    requireTty('Approving a payment');
+    const pending = findPendingApproval(ctx.network, id);
+    await requireApprovalSecret(deps);
+    const core = { network: ctx.network, config: ctx.config, provider };
+    const wallet = await openWallet({
+        ...core,
+        passphrase: () => obtainPassphrase(),
+        onWarning: (text) => process.stderr.write(text + '\n'),
+    });
+    // Re-decided now, against today's ledger: every rule except the threshold
+    // still applies. A deny here leaves the approval pending.
+    const plan = await planApprovedSend(wallet, core, {
+        to: pending.address,
+        amountSats: pending.amountSats,
+        memo: pending.memo,
+        confirmedOnly: pending.confirmedOnly,
+    }, pending.approvalId);
+    const result = await executeSend(wallet, core, plan);
+    resolveApproval(ctx.network, pending.approvalId, 'approved', result.txid);
+    ctx.out.info(chalk.green('Approved and sent.'));
+    ctx.out.info(`  Approval:       ${pending.approvalId}`);
+    ctx.out.info(`  Txid:           ${result.txid}`);
+    ctx.out.info(`  Explorer:       ${result.explorerUrl}`);
+    ctx.out.result({
+        ok: true,
+        approval_id: pending.approvalId,
+        txid: result.txid,
+        recipient: pending.address,
+        amount_sats: result.amountSats,
+        fee_sats: result.feeSats,
+        explorer_url: result.explorerUrl,
+    });
+}
+export async function cmdApprovalsReject(ctx, id, deps) {
+    requireTty('Rejecting a payment');
+    const pending = findPendingApproval(ctx.network, id);
+    await requireApprovalSecret(deps);
+    resolveApproval(ctx.network, pending.approvalId, 'rejected');
+    ctx.out.info(chalk.yellow(`Rejected ${pending.approvalId} — nothing was sent.`));
+    ctx.out.result({ ok: true, approval_id: pending.approvalId, resolution: 'rejected' });
+}
+export async function cmdApprovalsSetSecret(ctx, deps) {
+    requireTty('Setting the approval secret');
+    if (approvalSecretConfigured()) {
+        const promptOld = deps?.promptOldSecret ?? (() => askHidden('Current approval secret: '));
+        if (!verifyApprovalSecret(await promptOld()))
+            throw badApprovalSecret();
+    }
+    const promptNew = deps?.promptNewSecret ?? (() => askHidden('New approval secret: '));
+    const first = await promptNew();
+    if (first === '') {
+        throw usageError('empty_approval_secret', 'The approval secret cannot be empty.');
+    }
+    const second = await (deps?.promptNewSecret
+        ? deps.promptNewSecret()
+        : askHidden('Repeat approval secret: '));
+    if (first !== second) {
+        throw usageError('approval_secret_mismatch', 'The secrets do not match; nothing was changed.');
+    }
+    storeApprovalSecret(first);
+    process.stderr.write(chalk.yellow('Approval secret set. Keep it in your head: never in a file, script, or environment variable — that separation is what stops an agent from approving its own payments.') + '\n');
+    ctx.out.result({ ok: true, approval_secret_configured: true });
+}

package/dist/commands/balance.d.ts

@@ -0,0 +1,3 @@
+import type { ChainProvider } from '../chain/provider.js';
+import type { Ctx } from '../context.js';
+export declare function cmdBalance(ctx: Ctx, provider?: ChainProvider): Promise<void>;

package/dist/commands/balance.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { getBalance } from '../core/balance.js';
+import { formatSats } from '../units.js';
+export async function cmdBalance(ctx, provider) {
+    const balance = await getBalance({ network: ctx.network, config: ctx.config, provider });
+    ctx.out.info(chalk.bold(`Balance (${ctx.network === 'test' ? 'testnet' : 'mainnet'})`));
+    if (balance.backend === 'brc100') {
+        ctx.out.info(`  Spendable:    ${formatSats(balance.confirmedSats)}`);
+        ctx.out.info('  Custody:      external BRC-100 wallet app (experimental)');
+    }
+    else {
+        ctx.out.info(`  Confirmed:    ${formatSats(balance.confirmedSats)}`);
+        ctx.out.info(`  Unconfirmed:  ${formatSats(balance.unconfirmedSats)}`);
+        ctx.out.info(`  Total:        ${formatSats(balance.confirmedSats + balance.unconfirmedSats)}`);
+        ctx.out.info(`  Tracked addresses: ${balance.addresses.length}`);
+    }
+    ctx.out.result({
+        ok: true,
+        confirmed_sats: balance.confirmedSats,
+        unconfirmed_sats: balance.unconfirmedSats,
+        addresses: balance.addresses.map((a) => ({
+            address: a.address,
+            confirmed_sats: a.confirmedSats,
+            unconfirmed_sats: a.unconfirmedSats,
+        })),
+        ...(balance.backend ? { backend: balance.backend } : {}),
+    });
+}

package/dist/commands/donate.d.ts

@@ -0,0 +1,8 @@
+import type { ChainProvider } from '../chain/provider.js';
+import type { Ctx } from '../context.js';
+export interface DonateOptions {
+    yes?: boolean;
+    allowLarge?: boolean;
+    dryRun?: boolean;
+}
+export declare function cmdDonate(ctx: Ctx, amount: string | undefined, opts: DonateOptions, provider?: ChainProvider): Promise<void>;

package/dist/commands/donate.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { cmdSend } from './send.js';
+// TODO: the testnet address is still a well-known placeholder (no one holds
+// its key) — replace if testnet donations ever matter.
+const DONATION_ADDRESS = {
+    main: '131CswxfV8Swi8zUSc3XfH9tEJLxzxmpa4',
+    test: 'mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn',
+};
+const DEFAULT_AMOUNT = '10000';
+export async function cmdDonate(ctx, amount, opts, provider) {
+    if (ctx.network === 'test') {
+        process.stderr.write(chalk.yellow('NOTE: the testnet donation address is a PLACEHOLDER — coins sent to it are unrecoverable. Use --dry-run.') + '\n');
+    }
+    process.stderr.write('Thanks for supporting bsv-pay!\n');
+    await cmdSend(ctx, DONATION_ADDRESS[ctx.network], amount ?? DEFAULT_AMOUNT, 'bsv-pay donation', { ...opts }, provider);
+}

package/dist/commands/fetch.d.ts

@@ -0,0 +1,13 @@
+import type { ChainProvider } from '../chain/provider.js';
+import type { Ctx } from '../context.js';
+export interface FetchOptions {
+    maxPrice?: string;
+}
+/**
+ * `bsv-pay fetch <url>` — GET a resource, automatically paying a BRC-105
+ * 402 within policy. The body is the machine output (raw to stdout, or
+ * inside the --json object); everything about the payment goes to stderr.
+ * Exit 8 = capped/denied before money moved, 9 = queued for approval,
+ * 10 = paid but the server refused the content (txid in the error).
+ */
+export declare function cmdFetch(ctx: Ctx, url: string, opts: FetchOptions, provider?: ChainProvider): Promise<void>;

package/dist/commands/fetch.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { openWallet } from '../core/wallet.js';
+import { paidFetch } from '../http402/client.js';
+import { formatSats, parseAmount } from '../units.js';
+import { obtainPassphrase } from '../wallet/wallet.js';
+/**
+ * `bsv-pay fetch <url>` — GET a resource, automatically paying a BRC-105
+ * 402 within policy. The body is the machine output (raw to stdout, or
+ * inside the --json object); everything about the payment goes to stderr.
+ * Exit 8 = capped/denied before money moved, 9 = queued for approval,
+ * 10 = paid but the server refused the content (txid in the error).
+ */
+export async function cmdFetch(ctx, url, opts, provider) {
+    const maxPriceSats = opts.maxPrice !== undefined ? parseAmount(opts.maxPrice) : undefined;
+    const core = { network: ctx.network, config: ctx.config, provider };
+    const wallet = await openWallet({
+        ...core,
+        passphrase: () => obtainPassphrase(),
+        onWarning: (text) => process.stderr.write(text + '\n'),
+    });
+    const result = await paidFetch(wallet, core, { url, maxPriceSats });
+    if (result.paid) {
+        process.stderr.write(chalk.green(`paid ${formatSats(result.payment.amountSats)} (+${result.payment.feeSats} sats fee, txid ${result.payment.txid.slice(0, 12)}…) for ${url}`) + '\n');
+    }
+    else {
+        process.stderr.write(`no payment required (HTTP ${result.status})\n`);
+    }
+    if (ctx.json) {
+        ctx.out.result({
+            ok: true,
+            status: result.status,
+            paid: result.paid,
+            ...(result.contentType !== undefined && { content_type: result.contentType }),
+            ...(result.payment && {
+                amount_sats: result.payment.amountSats,
+                fee_sats: result.payment.feeSats,
+                txid: result.payment.txid,
+                address: result.payment.address,
+            }),
+            body: result.body,
+        });
+    }
+    else {
+        // the resource itself is the machine output
+        process.stdout.write(result.body);
+        if (result.body.length > 0 && !result.body.endsWith('\n'))
+            process.stdout.write('\n');
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,11 @@
+import type { Ctx } from '../context.js';
+import { type ConnectBrc100Options } from '../wallet/brc100.js';
+export interface InitOptions {
+    importSeed?: boolean;
+    importWif?: boolean;
+    force?: boolean;
+    encrypt?: boolean;
+    brc100?: boolean;
+    experimentalBrc100?: boolean;
+}
+export declare function cmdInit(ctx: Ctx, opts: InitOptions, brc100Connect?: ConnectBrc100Options): Promise<void>;