@bfun-bot/cli 1.0.5

package/dist/commands/login.js

@@ -0,0 +1,109 @@
+import chalk from 'chalk';
+import { writeConfig, clearConfig, CONFIG_PATH } from '../lib/config.js';
+import { agent, handleApiError } from '../lib/api.js';
+import { success } from '../lib/display.js';
+export function registerLogin(program) {
+    program
+        .command('login')
+        .description('Authenticate with your BFunBot API key')
+        .option('--api-key <key>', 'API key (bfbot_...)')
+        .option('--url', 'Open the BFunBot API keys page in your browser')
+        .action(async (opts) => {
+        if (opts.url) {
+            const url = 'https://bfun.bot/settings/api-keys';
+            console.log(`Open this URL to get your API key:\n\n  ${chalk.cyan(url)}\n`);
+            // Try to open browser
+            try {
+                const { exec } = await import('node:child_process');
+                const cmd = process.platform === 'darwin' ? 'open'
+                    : process.platform === 'win32' ? 'start'
+                        : 'xdg-open';
+                exec(`${cmd} ${url}`);
+            }
+            catch {
+                // browser open is best-effort
+            }
+            return;
+        }
+        let apiKey = opts.apiKey;
+        if (!apiKey) {
+            // Interactive prompt with masked input (first 8 chars visible)
+            const VISIBLE_PREFIX = 8;
+            const prompt = 'Enter your API key: ';
+            process.stdout.write(prompt);
+            apiKey = await new Promise((resolve) => {
+                let input = '';
+                const stdin = process.stdin;
+                const wasRaw = stdin.isRaw;
+                if (stdin.isTTY) {
+                    stdin.setRawMode(true);
+                }
+                stdin.resume();
+                stdin.setEncoding('utf8');
+                function redraw() {
+                    process.stdout.write(`\r${prompt}`);
+                    if (input.length <= VISIBLE_PREFIX) {
+                        process.stdout.write(input);
+                    }
+                    else {
+                        process.stdout.write(input.slice(0, VISIBLE_PREFIX) + '*'.repeat(input.length - VISIBLE_PREFIX));
+                    }
+                }
+                const onData = (ch) => {
+                    const c = ch.toString();
+                    if (c === '\n' || c === '\r') {
+                        stdin.removeListener('data', onData);
+                        if (stdin.isTTY)
+                            stdin.setRawMode(wasRaw ?? false);
+                        stdin.pause();
+                        process.stdout.write('\n');
+                        resolve(input.trim());
+                    }
+                    else if (c === '\u0003') {
+                        process.stdout.write('\n');
+                        process.exit(0);
+                    }
+                    else if (c === '\u007f' || c === '\b') {
+                        if (input.length > 0) {
+                            input = input.slice(0, -1);
+                            process.stdout.write(`\r${prompt}${' '.repeat(input.length + 1)}`);
+                            redraw();
+                        }
+                    }
+                    else {
+                        for (const char of c) {
+                            if (char >= ' ')
+                                input += char;
+                        }
+                        redraw();
+                    }
+                };
+                stdin.on('data', onData);
+            });
+        }
+        if (!apiKey || !apiKey.startsWith('bfbot_')) {
+            console.error('Error: Invalid API key. Keys start with bfbot_');
+            process.exit(1);
+        }
+        // Save key first so the API call can use it
+        writeConfig({ apiKey });
+        // Verify the key works
+        try {
+            const me = await agent.me();
+            success(`Logged in as ${chalk.bold('@' + (me.twitter_username || me.twitter_user_id))}`);
+            console.log(`  Config saved to ${chalk.dim(CONFIG_PATH)}`);
+        }
+        catch (err) {
+            // Key is bad — clear it
+            clearConfig();
+            handleApiError(err);
+        }
+    });
+    program
+        .command('logout')
+        .description('Clear stored credentials')
+        .action(() => {
+        clearConfig();
+        success('Logged out. Credentials cleared.');
+    });
+}

package/dist/commands/quota.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot quota
+ */
+import { Command } from 'commander';
+export declare function registerQuota(program: Command): void;

package/dist/commands/quota.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { printTable } from '../lib/display.js';
+export function registerQuota(program) {
+    program
+        .command('quota')
+        .description('Show daily token creation quota per chain')
+        .action(async (_, cmd) => {
+        try {
+            const res = await agent.quota();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            printTable(['Chain', 'Free Used', 'Free Limit', 'Sponsored', 'Can Create'], res.chains.map((c) => [
+                chalk.bold(c.chain.charAt(0).toUpperCase() + c.chain.slice(1)),
+                `${c.free_used_today}`,
+                `${c.free_limit}`,
+                `${c.sponsored_remaining}`,
+                c.can_create_paid ? chalk.green('Yes') : chalk.dim('No'),
+            ]));
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot skills
+ */
+import { Command } from 'commander';
+export declare function registerSkills(program: Command): void;

package/dist/commands/skills.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+export function registerSkills(program) {
+    program
+        .command('skills')
+        .description('List available BFunBot agent capabilities')
+        .action(async (_, cmd) => {
+        try {
+            const res = await agent.skills();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            console.log();
+            console.log(chalk.bold.cyan(`Available Skills (${res.total})`));
+            console.log(chalk.dim('─'.repeat(50)));
+            for (const skill of res.skills) {
+                console.log();
+                console.log(`  ${chalk.bold(skill.name)}`);
+                console.log(`  ${skill.description}`);
+                if (skill.example) {
+                    console.log(`  ${chalk.dim(skill.example)}`);
+                }
+            }
+            console.log();
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot status <jobId>
+ */
+import { Command } from 'commander';
+export declare function registerStatus(program: Command): void;

package/dist/commands/status.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { printCard, fmtDate } from '../lib/display.js';
+export function registerStatus(program) {
+    program
+        .command('status <jobId>')
+        .description('Check the status of a token creation job')
+        .action(async (jobId, _, cmd) => {
+        try {
+            const job = await agent.jobStatus(jobId);
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(job, null, 2));
+                return;
+            }
+            const statusColor = job.status === 'completed' ? chalk.green
+                : job.status === 'failed' ? chalk.red
+                    : job.status === 'processing' ? chalk.yellow
+                        : chalk.dim;
+            printCard(`Job ${job.job_id}`, [
+                ['Status', statusColor(job.status)],
+                ['Chain', job.chain],
+                ['Token', job.token_address],
+                ['Error', job.error ? chalk.red(job.error) : undefined],
+                ['Created', fmtDate(job.created_at)],
+                ['Completed', fmtDate(job.completed_at)],
+            ]);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/token.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot token create / bfun token info
+ */
+import { Command } from 'commander';
+export declare function registerToken(program: Command): void;

package/dist/commands/token.js

@@ -0,0 +1,150 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { agent, handleApiError } from '../lib/api.js';
+import { printCard, fmtUsd, fmtDate } from '../lib/display.js';
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 120_000;
+const EXPLORER_URLS = {
+    bsc: 'https://bscscan.com/token/',
+};
+export function registerToken(program) {
+    const tokenCmd = program
+        .command('token')
+        .description('Token creation and info');
+    // ── token create ──────────────────────────────────────
+    tokenCmd
+        .command('create')
+        .description('Deploy a new token')
+        .option('--name <name>', 'Token name')
+        .option('--symbol <symbol>', 'Token symbol')
+        .option('--description <desc>', 'Token description')
+        .option('--source <url>', 'Twitter/X post URL (insight source). Tweet image used as token image if --image-url not provided')
+        .option('--image-url <url>', 'Image URL (HTTPS or IPFS) — overrides source tweet image')
+        .option('--platform <platform>', 'Platform override (flap or fourmeme)')
+        .option('--no-wait', 'Return job ID without waiting for deployment')
+        .action(async (opts, cmd) => {
+        try {
+            let { name, symbol } = opts;
+            const chain = 'bsc'; // BFunBot is BSC-only
+            const isJson = cmd.optsWithGlobals().json;
+            // Interactive prompts for missing required fields
+            if (!name || !symbol) {
+                const readline = await import('node:readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+                if (!name)
+                    name = await ask('Token name: ');
+                if (!symbol)
+                    symbol = await ask('Symbol: ');
+                if (!opts.source) {
+                    const srcAnswer = await ask('Source tweet URL (optional, press Enter to skip): ');
+                    if (srcAnswer)
+                        opts.source = srcAnswer;
+                }
+                if (!opts.imageUrl) {
+                    const imgHint = opts.source ? ' (overrides source tweet image)' : '';
+                    const imgAnswer = await ask(`Token image URL${imgHint} (optional, press Enter to skip): `);
+                    if (imgAnswer)
+                        opts.imageUrl = imgAnswer;
+                }
+                rl.close();
+            }
+            // Validate source URL if provided
+            if (opts.source) {
+                const twitterPattern = /^https?:\/\/(?:(?:www\.)?twitter\.com|x\.com)\/[A-Za-z0-9_]+\/status\/\d+/;
+                if (!twitterPattern.test(opts.source)) {
+                    console.error(chalk.red('Error:') + ' --source must be a valid Twitter/X post URL (e.g. https://x.com/user/status/123)');
+                    process.exit(1);
+                }
+            }
+            const spinner = ora('Creating token...').start();
+            const result = await agent.tokenCreate({
+                name,
+                symbol: symbol.toUpperCase(),
+                chain,
+                description: opts.description,
+                source_url: opts.source,
+                image_url: opts.imageUrl,
+                platform: opts.platform,
+            });
+            spinner.succeed(`Job created (ID: ${result.job_id})`);
+            if (!opts.wait) {
+                if (isJson) {
+                    console.log(JSON.stringify(result, null, 2));
+                }
+                else {
+                    console.log(`  Check status with: ${chalk.cyan(`bfunbot status ${result.job_id}`)}`);
+                }
+                return;
+            }
+            // Poll for completion
+            const pollSpinner = ora('Waiting for deployment...').start();
+            const startTime = Date.now();
+            while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+                await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                pollSpinner.text = `Waiting for deployment... (${elapsed}s)`;
+                const job = await agent.jobStatus(String(result.job_id));
+                if (job.status === 'completed' && job.token_address) {
+                    pollSpinner.succeed('Token deployed!');
+                    if (isJson) {
+                        console.log(JSON.stringify(job, null, 2));
+                        return;
+                    }
+                    printCard('Token Deployed', [
+                        ['Address', job.token_address],
+                        ['Chain', 'BSC'],
+                        ['View', `${EXPLORER_URLS.bsc}${job.token_address}`],
+                    ]);
+                    return;
+                }
+                if (job.status === 'failed') {
+                    pollSpinner.fail('Token creation failed');
+                    console.error(`  ${job.error || 'Unknown error'}`);
+                    process.exit(1);
+                }
+            }
+            // Timeout
+            pollSpinner.warn('Token creation still in progress');
+            console.log(`  Check status with: ${chalk.cyan(`bfunbot status ${result.job_id}`)}`);
+        }
+        catch (err) {
+            ora().fail('Token creation failed');
+            handleApiError(err);
+        }
+    });
+    // ── token info ────────────────────────────────────────
+    tokenCmd
+        .command('info <address>')
+        .description('Get token details')
+        .option('--chain <chain>', 'Chain hint (base, bsc, solana)')
+        .action(async (address, opts, cmd) => {
+        try {
+            const res = await agent.tokenInfo(address, opts.chain);
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            const explorerBase = EXPLORER_URLS[res.chain] || '';
+            printCard(`${res.symbol} — ${res.name}`, [
+                ['Address', res.token_address],
+                ['Chain', res.chain],
+                ['Platform', res.platform],
+                ['Creator', res.creator_twitter_username ? `@${res.creator_twitter_username}` : undefined],
+                ['Price', fmtUsd(res.price_usd)],
+                ['Market Cap', fmtUsd(res.market_cap_usd)],
+                ['24h Volume', fmtUsd(res.volume_24h_usd)],
+                ['Creator Reward', fmtUsd(res.creator_reward_usd)],
+                ['Created', fmtDate(res.created_at)],
+                ['Explorer', explorerBase ? `${explorerBase}${res.token_address}` : undefined],
+            ]);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/tokens.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot tokens created
+ */
+import { Command } from 'commander';
+export declare function registerTokens(program: Command): void;

package/dist/commands/tokens.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import { agent, handleApiError } from '../lib/api.js';
+import { printTable, shortAddr, fmtDate } from '../lib/display.js';
+export function registerTokens(program) {
+    const tokensCmd = program
+        .command('tokens')
+        .description('Token listing commands');
+    tokensCmd
+        .command('created')
+        .description('List tokens you have created')
+        .option('--page <n>', 'Page number', '1')
+        .option('--page-size <n>', 'Items per page', '20')
+        .action(async (opts, cmd) => {
+        try {
+            const page = parseInt(opts.page, 10);
+            const pageSize = parseInt(opts.pageSize, 10);
+            const res = await agent.tokensCreated(page, pageSize);
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(res, null, 2));
+                return;
+            }
+            if (res.tokens.length === 0) {
+                console.log('\nNo tokens created yet.\n');
+                return;
+            }
+            console.log(chalk.dim(`\nShowing ${res.tokens.length} of ${res.total} tokens (page ${page})\n`));
+            printTable(['Symbol', 'Name', 'Chain', 'Platform', 'Address', 'Created'], res.tokens.map((t) => [
+                chalk.bold(t.symbol),
+                t.name,
+                t.chain,
+                t.platform || '—',
+                shortAddr(t.token_address),
+                fmtDate(t.created_at),
+            ]));
+            if (res.has_more) {
+                console.log(chalk.dim(`  Next page: bfunbot tokens created --page ${page + 1}`));
+                console.log();
+            }
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,5 @@
+/**
+ * bfunbot whoami
+ */
+import { Command } from 'commander';
+export declare function registerWhoami(program: Command): void;

package/dist/commands/whoami.js

@@ -0,0 +1,25 @@
+import { agent, handleApiError } from '../lib/api.js';
+import { printCard, fmtDate } from '../lib/display.js';
+export function registerWhoami(program) {
+    program
+        .command('whoami')
+        .description('Show your account info')
+        .action(async (_, cmd) => {
+        try {
+            const me = await agent.me();
+            const isJson = cmd.optsWithGlobals().json;
+            if (isJson) {
+                console.log(JSON.stringify(me, null, 2));
+                return;
+            }
+            printCard('Account', [
+                ['Twitter', me.twitter_username ? `@${me.twitter_username}` : me.twitter_user_id],
+                ['Followers', me.followers_count?.toLocaleString()],
+                ['Joined', fmtDate(me.joined_at)],
+            ]);
+        }
+        catch (err) {
+            handleApiError(err);
+        }
+    });
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * BFunBot CLI — deploy tokens, check balances, and manage your AI agent.
+ *
+ * @package @bfunbot/cli
+ */
+import { Command } from 'commander';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { enableDebug } from './lib/api.js';
+import { registerLogin } from './commands/login.js';
+import { registerWhoami } from './commands/whoami.js';
+import { registerTokens } from './commands/tokens.js';
+import { registerToken } from './commands/token.js';
+import { registerStatus } from './commands/status.js';
+import { registerBalances } from './commands/balances.js';
+import { registerQuota } from './commands/quota.js';
+import { registerSkills } from './commands/skills.js';
+import { registerLlm } from './commands/llm.js';
+import { registerConfig } from './commands/config.js';
+import { registerAbout } from './commands/about.js';
+import { registerFees } from './commands/fees.js';
+// Read version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('bfunbot')
+    .description('BFunBot CLI — deploy tokens, check balances, and manage your AI agent')
+    .version(pkg.version)
+    .option('--json', 'Output raw JSON (machine-readable)')
+    .option('--debug', 'Verbose HTTP request/response logging')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.debug) {
+        enableDebug();
+    }
+});
+// Show about box on first run (skip if user is running 'bfunbot about' directly)
+const welcomeMarker = join(homedir(), '.bfunbot', '.welcomed');
+const isAboutCommand = process.argv[2] === 'about';
+if (!existsSync(welcomeMarker) && !isAboutCommand) {
+    try {
+        const W = 43;
+        const pad = (t) => t + ' '.repeat(Math.max(0, W - t.length));
+        const lines = [
+            '', '   B F U N . B O T', '',
+            '   Deploy tokens. Earn fees.', '   Self-fund your AI agent.', '',
+            `   Version    ${pkg.version}`,
+            '   Website    bfun.bot',
+            '   Docs       bfun.bot/docs/agent',
+            '   GitHub     github.com/BFunBot',
+            '', '   BSC', '',
+        ];
+        console.log();
+        console.log(`  \x1b[36m╔${'═'.repeat(W)}╗\x1b[0m`);
+        for (const l of lines)
+            console.log(`  \x1b[36m║\x1b[0m${pad(l)}\x1b[36m║\x1b[0m`);
+        console.log(`  \x1b[36m╚${'═'.repeat(W)}╝\x1b[0m`);
+        console.log();
+        const bfunDir = join(homedir(), '.bfunbot');
+        if (!existsSync(bfunDir))
+            mkdirSync(bfunDir, { recursive: true });
+        writeFileSync(welcomeMarker, new Date().toISOString());
+    }
+    catch {
+        // best-effort
+    }
+}
+// Register all commands
+registerLogin(program);
+registerWhoami(program);
+registerTokens(program);
+registerToken(program);
+registerStatus(program);
+registerBalances(program);
+registerQuota(program);
+registerSkills(program);
+registerLlm(program);
+registerConfig(program);
+registerAbout(program);
+registerFees(program);
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,32 @@
+import type { ApiErrorResponse } from '../types.js';
+export declare function enableDebug(): void;
+export declare class ApiError extends Error {
+    statusCode: number;
+    statusText: string;
+    body?: ApiErrorResponse | undefined;
+    constructor(statusCode: number, statusText: string, body?: ApiErrorResponse | undefined);
+}
+/**
+ * Print a friendly error message to stderr and exit.
+ */
+export declare function handleApiError(err: unknown): never;
+export declare const agent: {
+    me: () => Promise<import("../types.js").MeResponse>;
+    tokensCreated: (page?: number, pageSize?: number) => Promise<import("../types.js").CreatedTokensResponse>;
+    tokenCreate: (body: import("../types.js").TokenCreateRequest) => Promise<import("../types.js").TokenCreateResponse>;
+    tokenInfo: (address: string, chain?: string) => Promise<import("../types.js").TokenInfoResponse>;
+    jobStatus: (jobId: string) => Promise<import("../types.js").JobStatusResponse>;
+    walletBalance: () => Promise<import("../types.js").WalletBalanceResponse>;
+    creditBalance: () => Promise<import("../types.js").CreditBalanceResponse>;
+    reloadCredits: () => Promise<import("../types.js").AgentReloadResponse>;
+    disableReload: () => Promise<void>;
+    quota: () => Promise<import("../types.js").QuotaResponse>;
+    skills: () => Promise<import("../types.js").SkillsResponse>;
+    feesSummary: () => Promise<import("../types.js").FeeSummaryResponse>;
+    feesEarnings: (chain: string) => Promise<import("../types.js").FeeEarningsBsc>;
+    feesToken: (chain: string, platform: string, tokenAddress: string) => Promise<import("../types.js").FeeTokenResponse>;
+};
+export declare const llm: {
+    models: () => Promise<import("../types.js").LlmModelsResponse>;
+    openclawConfig: () => Promise<import("../types.js").OpenclawConfigResponse>;
+};